Update backend_app/rag_hf.py

backend_app/rag_hf.py

@@ -13,21 +13,28 @@ from .config import (
     EMBED_MODEL_NAME,
     MIN_TOP_SCORE,
     WEB_MAX_RESULTS,
+    HF_TOKEN,
+    HF_MODEL,
 )
 from .fetcher import fetch_page_text
 from .web_search import web_search
 
-HF_TOKEN = os.getenv("HF_TOKEN", "")
-HF_MODEL = os.getenv("HF_MODEL", "HuggingFaceH4/zephyr-7b-beta")  # you can change later
 
 class RAGEngineHF:
     def __init__(self):
         self.embedder = SentenceTransformer(EMBED_MODEL_NAME)
+
+        # Load FAISS index + docs
         self.index = faiss.read_index(FAISS_INDEX_PATH)
         with open(DOCSTORE_PATH, "rb") as f:
             self.docs: List[Dict] = pickle.load(f)
 
-        self.client = InferenceClient(model=HF_MODEL, token=HF_TOKEN)
+        # Prefer config values; give safe default model if empty
+        model_name = (HF_MODEL or "google/gemma-2-2b-it").strip()
+        token = (HF_TOKEN or "").strip()
+
+        self.client = InferenceClient(model=model_name, token=token)
+
         self.TOP_K = 5
         self.MAX_CONTEXT_CHARS_PER_DOC = 1800
 
@@ -36,47 +43,69 @@ class RAGEngineHF:
         q_emb = np.array(q_emb, dtype="float32")
         scores, ids = self.index.search(q_emb, k)
 
-        out = []
+        out: List[Dict] = []
         for rank, doc_id in enumerate(ids[0]):
             if doc_id == -1:
                 continue
             d = self.docs[int(doc_id)]
-            out.append({
-                "rank": rank + 1,
-                "score": float(scores[0][rank]),
-                "text": d["text"],
-                "meta": d["meta"],
-            })
+            out.append(
+                {
+                    "rank": rank + 1,
+                    "score": float(scores[0][rank]),
+                    "text": d.get("text", ""),
+                    "meta": d.get("meta", {}),
+                }
+            )
         return out
 
     def _needs_web_fallback(self, contexts: List[Dict]) -> bool:
         return (not contexts) or (contexts[0]["score"] < MIN_TOP_SCORE)
 
     def fetch_web_context(self, query: str) -> Tuple[List[Dict], List[Dict]]:
+        """
+        Optional fallback: uses web_search() -> fetch_page_text().
+        web_search() should return [] when rate-limited, so this won't crash.
+        """
         queries = [f"site:foodsystemsdashboard.org {query}", query]
-        links, seen = [], set()
+        links: List[Dict] = []
+        seen = set()
 
         for q in queries:
             for r in web_search(q, max_results=WEB_MAX_RESULTS):
-                if r["url"] not in seen:
+                url = r.get("url")
+                if url and url not in seen:
                     links.append(r)
-                    seen.add(r["url"])
+                    seen.add(url)
             if len(links) >= WEB_MAX_RESULTS:
                 break
 
-        contexts, sources = [], []
+        contexts: List[Dict] = []
+        sources: List[Dict] = []
+
         for r in links[:WEB_MAX_RESULTS]:
             try:
                 page = fetch_page_text(r["url"], use_cache=True)
-                contexts.append({
-                    "rank": len(contexts) + 1,
-                    "score": 0.0,
-                    "text": page["text"],
-                    "meta": {"url": page["url"], "title": page["title"], "chunk": 0},
-                })
-                sources.append({"title": page["title"], "url": page["url"]})
-            except:
+                contexts.append(
+                    {
+                        "rank": len(contexts) + 1,
+                        "score": 0.0,
+                        "text": page.get("text", ""),
+                        "meta": {
+                            "url": page.get("url", r["url"]),
+                            "title": page.get("title", r.get("title", "Source")),
+                            "chunk": 0,
+                        },
+                    }
+                )
+                sources.append(
+                    {
+                        "title": page.get("title", r.get("title", "Source")),
+                        "url": page.get("url", r["url"]),
+                    }
+                )
+            except Exception:
                 continue
+
         return contexts, sources
 
     def answer(self, query: str, preferred_lang: Optional[str] = None) -> Dict:
@@ -85,6 +114,7 @@ class RAGEngineHF:
         contexts = local
         sources = self._unique_sources(local)
 
+        # Web fallback only if local seems weak
         if self._needs_web_fallback(local):
             web_ctx, web_src = self.fetch_web_context(query)
             if web_ctx:
@@ -93,8 +123,10 @@ class RAGEngineHF:
                 sources = web_src
 
         context_block = "\n\n".join(
-            [f"[{i+1}] {c['meta']['title']}\n{c['text'][:self.MAX_CONTEXT_CHARS_PER_DOC]}"
-             for i, c in enumerate(contexts)]
+            [
+                f"[{i+1}] {c.get('meta', {}).get('title', 'Source')}\n{c.get('text', '')[:self.MAX_CONTEXT_CHARS_PER_DOC]}"
+                for i, c in enumerate(contexts)
+            ]
         )
 
         lang_line = f"Respond in {preferred_lang}.\n" if preferred_lang else ""
@@ -102,56 +134,59 @@ class RAGEngineHF:
         prompt = f"""
 You are the SysLink Food System assistant.
 
-You MUST answer using ONLY the information provided in the retrieved context.
+You MUST answer using ONLY the information provided below.
+Do NOT invent facts.
 
 Write in simple, clear language.
 Keep responses MEDIUM length (8–14 lines).
-Avoid being too brief or too detailed.
-
-Your focus areas are:
-- Food systems and agri-food value chains
-- Farmers, markets, logistics, and distribution
-- Sustainability and food security
-- Policy, programs, and institutional support
-
-Rules:
-- Be factual, neutral, and helpful
-- Avoid technical jargon unless it appears in the context
-- Do not include opinions or speculation
-- Do not summarize irrelevant information
-- Do not mention the word “context” or “retrieved documents” in the final answer
+If information is missing, say what is missing.
 
 {lang_line}
 QUESTION: {query}
 
-CONTEXT:
+INFORMATION:
 {context_block}
 
 ANSWER:
-""".strip()       
-        messages = [
-            {"role": "system", "content": "You are the SysLink Food System assistant."},
-            {"role": "user", "content": prompt},
-        ]
-
-        resp = self.client.chat_completion(
-            messages=messages,
-            max_tokens=250,
-            temperature=0.2,
-        )
-
-        out = resp.choices[0].message.content.strip()
+""".strip()
+
+        # If token missing, we can still try public inference,
+        # but failures are common; return a helpful message.
+        token = (HF_TOKEN or "").strip()
+        if not token:
+            return {
+                "answer": "I’m running without an HF_TOKEN right now, so the AI response may fail. Please add HF_TOKEN in Space Settings → Secrets, then retry.",
+                "sources": sources,
+                "used": used,
+            }
+
+        # Try chat completion (works for conversational providers)
+        try:
+            messages = [
+                {"role": "system", "content": "You are the SysLink Food System assistant."},
+                {"role": "user", "content": prompt},
+            ]
+            resp = self.client.chat_completion(
+                messages=messages,
+                max_tokens=250,
+                temperature=0.2,
+            )
+            out = (resp.choices[0].message.content or "").strip()
+        except Exception as e:
+            # Fallback: return a visible error message (so you can debug)
+            out = f"Model error: {str(e)}"
 
         if not out:
-            out = "I couldn’t find enough reliable information in the provided sources. Please rephrase or share more details."
+            out = "I couldn’t generate an answer right now. Please try again."
 
         return {"answer": out, "sources": sources, "used": used}
 
     def _unique_sources(self, contexts: List[Dict]) -> List[Dict]:
         seen, out = set(), []
         for c in contexts:
-            u = c["meta"]["url"]
-            if u not in seen:
-                out.append({"title": c["meta"]["title"], "url": u})
+            meta = c.get("meta", {})
+            u = meta.get("url")
+            if u and u not in seen:
+                out.append({"title": meta.get("title", "Source"), "url": u})
                 seen.add(u)
         return out