Update app.py

app.py

@@ -110,8 +110,10 @@ def remote_generate(prompt: str, max_new_tokens: int = 512, temperature: float =
     if not HF_INFERENCE_API_KEY:
         raise Exception("HF_INFERENCE_API_KEY not set for remote generation")
 
-    url = f"https://api-inference.huggingface.co/models/{REMOTE_LLM_MODEL}"
-    headers = {"Authorization": f"Bearer {HF_INFERENCE_API_KEY}"}
+    # New router endpoint is required by HF (replaces api-inference.huggingface.co)
+    router_url = f"https://router.huggingface.co/models/{REMOTE_LLM_MODEL}"
+    old_url = f"https://api-inference.huggingface.co/models/{REMOTE_LLM_MODEL}"
+    headers = {"Authorization": f"Bearer {HF_INFERENCE_API_KEY}", "Accept": "application/json"}
     payload = {
         "inputs": prompt,
         "parameters": {
@@ -122,8 +124,19 @@ def remote_generate(prompt: str, max_new_tokens: int = 512, temperature: float =
         }
     }
 
-    logger.info(f"    → Remote inference request to {REMOTE_LLM_MODEL} (tokens={max_new_tokens}, temp={temperature})")
-    r = requests.post(url, headers=headers, json=payload, timeout=60)
+    logger.info(f"    → Remote inference request to router {REMOTE_LLM_MODEL} (tokens={max_new_tokens}, temp={temperature})")
+    try:
+        r = requests.post(router_url, headers=headers, json=payload, timeout=120)
+    except Exception as e:
+        logger.error(f"    ✗ Remote router request failed: {e}")
+        # Try older endpoint as a fallback
+        try:
+            logger.info("    → Attempting legacy api-inference endpoint as fallback")
+            r = requests.post(old_url, headers=headers, json=payload, timeout=120)
+        except Exception as e2:
+            logger.error(f"    ✗ Legacy endpoint request failed: {e2}")
+            return ""
+
     if r.status_code != 200:
         logger.error(f"    ✗ Remote inference error {r.status_code}: {r.text[:200]}")
         return ""
@@ -368,6 +381,92 @@ def generate_extractive_answer(query: str, retrieved_docs: List[Document]) -> Op
     return answer
 
 
+def scaffold_and_polish(query: str, retrieved_docs: List[Document], llm_client) -> Optional[str]:
+    """Create a concise scaffold (approx 150-220 words) from retrieved docs,
+    then ask the remote (or local) LLM to expand and polish it into a
+    320-420 word expert answer. Returns None if polishing fails.
+    """
+    logger.info(f"🔨 Building scaffold for polish: '{query}'")
+    import re
+
+    # Reuse sentence extraction logic but stop early for a compact scaffold
+    all_text = "\n\n".join([d.page_content for d in retrieved_docs[:12]])
+    sentences = re.split(r'(?<=[.!?])\s+', all_text)
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
+    if not sentences:
+        logger.warning("  ✗ No sentences to build scaffold")
+        return None
+
+    # Score sentences by overlap with query + fashion keywords
+    query_tokens = set(re.findall(r"\w+", query.lower()))
+    fashion_keywords = set(["outfit","wear","wardrobe","style","colors","layer","blazer",
+                            "trousers","dress","shoes","sweater","jacket","care","wool","fit",
+                            "tailor","neutral","accessory","season","fall"])
+    keywords = query_tokens.union(fashion_keywords)
+
+    scored = []
+    for s in sentences:
+        s_tokens = set(re.findall(r"\w+", s.lower()))
+        score = len(s_tokens & keywords)
+        score += min(2, len(s.split()) // 30)
+        scored.append((score, s))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    scaffold_parts = []
+    word_count = 0
+    for _, s in scored:
+        scaffold_parts.append(s)
+        word_count = len(" ".join(scaffold_parts).split())
+        if word_count >= 180:
+            break
+
+    scaffold = "\n\n".join(scaffold_parts).strip()
+    if not scaffold:
+        logger.warning("  ✗ Scaffold empty after selection")
+        return None
+
+    # Craft polish prompt
+    polish_prompt = f"""Please rewrite and expand the draft below into a clear, expert, natural-flowing answer of about 320-420 words to the question: {query}
+
+Requirements:
+- Keep paragraphs natural and connected.
+- Preserve factual content from the draft and avoid inventing unsupported facts.
+- Use a friendly, expert tone and provide practical, actionable advice.
+
+Draft:
+{scaffold}
+
+Answer:
+"""
+
+    logger.info("  → Polishing scaffold with LLM")
+    try:
+        if USE_REMOTE_LLM:
+            polished = remote_generate(polish_prompt, max_new_tokens=600, temperature=0.72, top_p=0.92)
+        else:
+            out = llm_client(polish_prompt, max_new_tokens=600, temperature=0.72, top_p=0.92, do_sample=True, num_beams=1)
+            polished = out[0].get('generated_text', '') if isinstance(out, list) and out else str(out)
+            polished = polished.strip()
+    except Exception as e:
+        logger.error(f"  ✗ Polishing error: {e}")
+        return None
+
+    if not polished:
+        logger.warning("  ✗ Polished output empty")
+        return None
+
+    final_words = polished.split()
+    fw = len(final_words)
+    if fw < 300:
+        logger.warning(f"  ✗ Polished output too short ({fw} words)")
+        return None
+    if fw > 460:
+        polished = ' '.join(final_words[:420]) + '...'
+
+    logger.info(f"  ✅ Polished answer ready ({len(polished.split())} words)")
+    return polished
+
+
 def retrieve_knowledge_langchain(
     query: str,
     vectorstore,
@@ -639,9 +738,20 @@ def generate_answer_langchain(
     
     if not llm_answer:
         logger.error(f"  ✗ All 2 LLM attempts failed")
-        # Fallback: use an extractive + template-based generator to produce a long,
-        # natural-flowing answer without using the LLM. This helps when the model
-        # repeatedly returns very short outputs or errors.
+        # Next attempt: if remote LLM is available, build a short scaffold from
+        # retrieved documents and ask the remote model to polish/expand it. This
+        # is more reliable than single-shot long generation on some models.
+        if USE_REMOTE_LLM:
+            try:
+                logger.info("  → Attempting scaffold-and-polish using remote LLM")
+                polished = scaffold_and_polish(query, retrieved_docs, llm_client)
+                if polished:
+                    logger.info("  ✅ Scaffold-and-polish produced an answer")
+                    return polished
+            except Exception as e:
+                logger.error(f"  ✗ Scaffold-and-polish error: {e}")
+
+        # Final fallback: extractive templated answer (guaranteed deterministic)
         try:
             logger.info("  → Using extractive fallback generator")
             fallback = generate_extractive_answer(query, retrieved_docs)