Update app.py

app.py

@@ -1,149 +1,45 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-MaterialMind – Hugging Face Spaces app
-- Same UI & templates you already have
-- Reads PDFs from HF dataset Azizahalq/materialmind-corpus
-- Builds/updates a local Chroma index at startup
-- Calls an API LLM (OpenAI or Together) via Space secrets
+MaterialMind – Flask app (form page → results page)
+Cloud LLM providers: OpenAI / Together / Hugging Face Inference
+- Set LLM_PROVIDER, LLM_MODEL, LLM_API_KEY in Space Secrets
+- RAG uses dataset Azizahalq/materialmind-corpus (via ensure_ready in rag_mini.py)
 """
 
 import os, re, json, textwrap
-import subprocess, shutil
-from typing import List, Tuple, Any, Dict
+from decimal import Decimal
+from typing import List, Tuple
+
 from flask import Flask, request, render_template, redirect, url_for, flash
 from flask_cors import CORS
 from filelock import FileLock
 
-# Silence tokenizers warning in HF
-os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+# ---- LLM client imports (lazy created in call_llm_cloud) ----
+# (packages added in requirements.txt)
 
-# ---- RAG helpers (portable) ----
-from rag_mini import (
-    ensure_dirs, bootstrap_corpus_and_index, search,
-    DATA_DIR, DEFAULT_TOPK
-)
+# ---- RAG helpers ----
+try:
+    # if you applied the dataset-fetch patch
+    from rag_mini import search, ensure_ready, DATA_DIR, DEFAULT_TOPK, DEFAULT_MODEL
+except Exception:
+    # fallback if ensure_ready is not present
+    from rag_mini import search, ensure_dirs as ensure_ready, DATA_DIR, DEFAULT_TOPK, DEFAULT_MODEL
 
 app = Flask(__name__)
-app.secret_key = os.getenv("FLASK_SECRET", "change-me")
+app.secret_key = "change-me"  # set a strong secret in production
 CORS(app)
 
-# HF runs on port 7860
-PORT = int(os.environ.get("PORT", "7860"))
-
 LOCK_PATH = (DATA_DIR.parent / ".rag_lock")
-DEFAULT_MODEL = os.getenv("LLM_MODEL", "gpt-4o-mini")
-LLM_PROVIDER  = os.getenv("LLM_PROVIDER", "openai")   # "openai" or "together"
-LLM_API_KEY   = os.getenv("LLM_API_KEY", "")
-
-# ---------- LLM caller (remote) ----------
-def call_llm(model: str, system_prompt: str, user_prompt: str) -> str:
-    provider = LLM_PROVIDER.lower().strip()
-    if provider == "openai":
-        try:
-            from openai import OpenAI
-            client = OpenAI(api_key=LLM_API_KEY)
-            resp = client.chat.completions.create(
-                model=model,
-                temperature=0.2,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_prompt},
-                ],
-            )
-            return resp.choices[0].message.content or ""
-        except Exception as e:
-            return f"[Error] OpenAI call failed: {e}"
-
-    elif provider == "together":
-        # Simple Together REST call (instruct/chat style)
-        import requests
-        url = "https://api.together.xyz/v1/chat/completions"
-        headers = {"Authorization": f"Bearer {LLM_API_KEY}", "Content-Type": "application/json"}
-        payload = {
-            "model": model,
-            "temperature": 0.2,
-            "messages": [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-        }
-        try:
-            r = requests.post(url, headers=headers, json=payload, timeout=120)
-            r.raise_for_status()
-            j = r.json()
-            return j["choices"][0]["message"]["content"]
-        except Exception as e:
-            return f"[Error] Together call failed: {e}"
-
-    return "[Error] Unknown LLM_PROVIDER. Set LLM_PROVIDER to 'openai' or 'together'."
-
-def extract_json_block(text: str):
-    m = re.search(r"```json\s*(\{.*?\})\s*```", text, flags=re.S | re.I)
-    s = m.group(1) if m else None
-    if not s:
-        m2 = re.search(r"(\{(?:[^{}]|(?1))*\})", text, flags=re.S)
-        s = m2.group(1) if m2 else None
-    if not s:
-        return None
-    try:
-        return json.loads(s)
-    except Exception:
-        last = s.rfind("}")
-        if last != -1:
-            try:
-                return json.loads(s[:last+1])
-            except Exception:
-                return None
-        return None
 
-def normalize_candidates_for_display(cands: List[Dict[str, Any]], max_total: float = 400.0) -> List[Dict[str, Any]]:
-    def _to_float(x):
-        try: return float(x)
-        except: return None
+# ------------- Cloud LLM switch -------------
+LLM_PROVIDER = (os.getenv("LLM_PROVIDER") or "hf").strip().lower()
+LLM_MODEL    = (os.getenv("LLM_MODEL") or
+                # safe default for HF Inference; change to your choice
+                "HuggingFaceH4/zephyr-7b-beta").strip()
+# For OpenAI/Together use LLM_API_KEY; for HF Inference use HUGGINGFACEHUB_API_TOKEN (or set LLM_API_KEY)
+LLM_API_KEY  = os.getenv("LLM_API_KEY")
 
-    for c in cands:
-        if "score_pct" in c and c["score_pct"] is not None:
-            try:
-                p = float(c["score_pct"])
-                c["score_pct"] = max(0.0, min(100.0, p))
-                c.setdefault("score_raw", c["score_pct"] * 4.0)
-                continue
-            except: pass
-
-        raw = None
-        v = c.get("score")
-        if isinstance(v, (int, float)):
-            f = float(v)
-            raw = (f * max_total) if f <= 1.5 else f
-        elif isinstance(v, str):
-            s = v.strip()
-            m = re.search(r"^\s*([\d.]+)\s*/\s*([\d.]+)\s*$", s)
-            if m:
-                num, den = _to_float(m.group(1)), _to_float(m.group(2))
-                if num is not None and den and den > 0: raw = max_total * (num/den)
-            if raw is None:
-                m2 = re.search(r"^\s*([\d.]+)\s*%\s*$", s)
-                if m2:
-                    p = _to_float(m2.group(1))
-                    if p is not None: raw = max_total * (p/100.0)
-            if raw is None:
-                f = _to_float(s)
-                if f is not None: raw = (f * max_total) if f <= 1.5 else f
-
-        if raw is None:
-            subs = c.get("subscores") or {}
-            if isinstance(subs, dict) and subs:
-                raw = sum(max(0.0, min(100.0, _to_float(v) or 0.0)) for v in subs.values())
-
-        raw = 0.0 if raw is None else max(0.0, min(max_total, float(raw)))
-        c["score_raw"] = raw
-        c["score_pct"] = round((raw / max_total) * 100.0, 1)
-
-    cands.sort(key=lambda z: z.get("score_raw", 0.0), reverse=True)
-    return cands
-
-# ---------- Prompt text ----------
 SYSTEM_RULES = """You are MaterialMind, a materials-selection assistant.
 Return two things:
 1) JSON with a ranked shortlist:
@@ -152,19 +48,19 @@ Return two things:
     {
       "name": "string",
       "score": 0,            // 0..400 (sum of 4 independent 0..100 utilities)
-      "score_pct": 0,        // score/4 -> 0..100 for display
+      "score_pct": 0,        // 0..100 normalized percentage for display
       "reasons": ["..."],
       "tradeoffs": ["..."],
       "citations": ["[1]", "[2]"]
     }
   ]
 }
-2) After the JSON, 3–6 concise bullets on trade-offs.
+2) After the JSON, provide 3–6 concise bullets on the trade-offs.
 Rules:
-- Use only provided context; cite with [1], [2], etc. No fabrication.
-- Utilities per criterion are in [0,1]. Lower cost => higher cost-utility.
-- Weights (performance, stability, cost, availability) are independent 0..100 (NOT normalized).
-- Prefer pitting/crevice metrics in chloride questions; keep units explicit.
+- Use only the provided context; cite with [1], [2] etc. No fabrication.
+- Per-criterion utilities are in [0,1]. Cost utility increases as cost decreases.
+- Weights (performance, stability, cost, availability) are independent 0..100 (not normalized).
+- Prefer pitting/crevice metrics for chlorides; keep units explicit.
 """
 
 ANSWER_TEMPLATE = """User constraints:
@@ -179,7 +75,8 @@ Independent priorities (0..100 each):
 - performance={w_perf}, stability={w_stab}, cost={w_cost}, availability={w_avail}
 
 Question:
-{question}
+For {environment} at {temperature}, shortlist materials that meet UTS ≥ {min_uts} MPa and density ≤ {max_density} g/cm^3.
+Consider budget={budget} and process={process}. Rank by performance, stability, cost, and availability.
 
 Context snippets (numbered):
 {context}
@@ -187,9 +84,17 @@ Context snippets (numbered):
 Citations:
 {citations}
 
-Now, first output ONLY the JSON block, then the short narrative.
+Now, first output ONLY the JSON block (no preamble). Then the short narrative.
 """
 
+# ---------- Utils ----------
+def to_dec(x, default: int) -> Decimal:
+    try:
+        s = (x or "").strip()
+        return Decimal(s if s else str(default))
+    except Exception:
+        return Decimal(default)
+
 def format_context(hits: List[Tuple[str, str]]) -> Tuple[str, str]:
     blocks, cites = [], []
     for i, (text, cite) in enumerate(hits, 1):
@@ -198,13 +103,99 @@ def format_context(hits: List[Tuple[str, str]]) -> Tuple[str, str]:
         cites.append(f"[{i}] {cite}")
     return "\n".join(blocks), "\n".join(cites)
 
+def extract_json_block(text: str):
+    # fenced JSON first
+    m = re.search(r"```json\s*(\{.*?\})\s*```", text, flags=re.S | re.I)
+    s = m.group(1) if m else None
+    if not s:
+        # fallback: first top-level object
+        m2 = re.search(r"(\{(?:[^{}]|(?1))*\})", text, flags=re.S)
+        s = m2.group(1) if m2 else None
+    if not s:
+        return None
+    try:
+        return json.loads(s)
+    except Exception:
+        last = s.rfind("}")
+        if last != -1:
+            try:
+                return json.loads(s[:last+1])
+            except Exception:
+                return None
+        return None
+
+# ---------- Cloud LLM caller ----------
+def call_llm_cloud(system: str, user: str) -> str:
+    provider = LLM_PROVIDER
+    model    = LLM_MODEL
+
+    if provider in ("openai", "oai"):
+        # pip: openai>=1.40
+        from openai import OpenAI
+        client = OpenAI(api_key=LLM_API_KEY)
+        resp = client.chat.completions.create(
+            model=model,
+            temperature=0.2,
+            max_tokens=1200,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user",   "content": user},
+            ],
+        )
+        return resp.choices[0].message.content
+
+    elif provider in ("together", "tg"):
+        # pip: together>=1.2.0
+        from together import Together
+        client = Together(api_key=LLM_API_KEY)
+        resp = client.chat.completions.create(
+            model=model,
+            temperature=0.2,
+            max_tokens=1200,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user",   "content": user},
+            ],
+        )
+        return resp.choices[0].message.content
+
+    else:
+        # Hugging Face Inference API
+        # token from LLM_API_KEY or HF env
+        from huggingface_hub import InferenceClient
+        hf_token = LLM_API_KEY or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+        client = InferenceClient(model=model, token=hf_token)
+
+        # Prefer chat if available, else plain text-generation
+        try:
+            out = client.chat_completion(
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user",   "content": user},
+                ],
+                max_tokens=1200,
+                temperature=0.2,
+            )
+            # InferenceClient returns a dataclass-like obj
+            return out.choices[0].message["content"]
+        except Exception:
+            gen = client.text_generation(
+                prompt=f"{system}\n\n{user}\n",
+                max_new_tokens=1200,
+                temperature=0.2,
+                do_sample=True,
+                stream=False,
+            )
+            return gen
+
 # ---------- Routes ----------
 @app.get("/")
 def index():
-    return render_template("index.html", default_model=DEFAULT_MODEL, default_k=DEFAULT_TOPK)
+    return render_template("index.html", default_model=LLM_MODEL, default_k=DEFAULT_TOPK)
 
 @app.post("/recommend")
 def recommend():
+    # Inputs
     environment  = request.form.get("environment", "").strip() or "seawater"
     temperature  = request.form.get("temperature", "").strip() or "20–25 °C"
     min_uts      = request.form.get("min_uts", "").strip() or "0"
@@ -212,41 +203,55 @@ def recommend():
     budget       = request.form.get("budget", "").strip() or "open"
     process      = request.form.get("process", "").strip() or "any"
 
-    # Hidden numeric weights set by JS (0..100 each; independent)
-    w_perf  = request.form.get("w_perf", "75")
-    w_stab  = request.form.get("w_stab", "100")
-    w_cost  = request.form.get("w_cost", "75")
-    w_avail = request.form.get("w_avail", "75")
+    # Independent priorities (0..100 each) hidden from UI via dropdowns
+    w_perf = to_dec(request.form.get("w_perf"), 75)
+    w_stab = to_dec(request.form.get("w_stab"), 100)
+    w_cost = to_dec(request.form.get("w_cost"), 75)
+    w_avail= to_dec(request.form.get("w_avail"), 75)
 
     try:
         k = int(request.form.get("k", DEFAULT_TOPK))
     except Exception:
         k = DEFAULT_TOPK
 
-    question = (
-        f"For {environment} at {temperature}, shortlist materials that meet "
-        f"UTS ≥ {min_uts} MPa and density ≤ {max_density} g/cm^3. "
-        f"Consider budget={budget} and process={process}. "
-        f"Rank by performance, stability, cost, and availability."
-    )
+    # Build retrieval query & fetch context
+    question = (f"For {environment} at {temperature}, shortlist materials that meet "
+                f"UTS ≥ {min_uts} MPa and density ≤ {max_density} g/cm^3. "
+                f"Consider budget={budget} and process={process}. "
+                f"Rank by performance, stability, cost, and availability.")
 
     hits = search(question, k=k)
     if not hits:
-        flash("No context found. Make sure your dataset is reachable and indexed.", "error")
+        flash("No context found. Please add sources or ensure dataset pull succeeded.", "error")
         return redirect(url_for("index"))
 
     ctx, cites = format_context(hits)
+
+    # Compose prompt
     user_prompt = ANSWER_TEMPLATE.format(
-        environment=environment, temperature=temperature, min_uts=min_uts,
-        max_density=max_density, budget=budget, process=process,
-        w_perf=w_perf, w_stab=w_stab, w_cost=w_cost, w_avail=w_avail,
-        question=question, context=ctx, citations=cites
+        environment=environment, temperature=temperature,
+        min_uts=min_uts, max_density=max_density, budget=budget, process=process,
+        w_perf=str(int(w_perf)), w_stab=str(int(w_stab)),
+        w_cost=str(int(w_cost)), w_avail=str(int(w_avail)),
+        context=ctx, citations=cites
     )
 
-    raw = call_llm(DEFAULT_MODEL, SYSTEM_RULES, user_prompt)
-    parsed = extract_json_block(raw) if raw else None
-    candidates = (parsed or {}).get("candidates", []) if parsed else []
-    candidates = normalize_candidates_for_display(candidates, max_total=400.0)
+    # Call cloud LLM
+    try:
+        # Use a short lock to prevent concurrent double calls on Spaces
+        try:
+            LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with FileLock(str(LOCK_PATH), timeout=1):
+                raw = call_llm_cloud(SYSTEM_RULES, user_prompt)
+        except Exception:
+            raw = call_llm_cloud(SYSTEM_RULES, user_prompt)
+    except Exception as e:
+        flash(f"LLM call failed: {e}", "error")
+        raw = ""
+        candidates = []
+    else:
+        parsed = extract_json_block(raw) if raw else None
+        candidates = (parsed or {}).get("candidates", []) if parsed else []
 
     return render_template(
         "results.html",
@@ -255,11 +260,10 @@ def recommend():
         environment=environment,
         temperature=temperature,
         raw_output=raw,
-        default_model=DEFAULT_MODEL,
+        default_model=LLM_MODEL,
         default_k=k,
     )
 
 if __name__ == "__main__":
-    ensure_dirs()
-    bootstrap_corpus_and_index()       # <-- download dataset + build/update index
-    app.run(host="0.0.0.0", port=PORT, debug=False)
+    ensure_ready()
+    app.run(host="0.0.0.0", port=7860, debug=False)  # Spaces default port