Update app.py

app.py

@@ -635,23 +635,21 @@ def generate_llm_answer(
     max_iterations = 0  # Single-shot only for speed
 
     def call_model(prompt, max_new_tokens, temperature):
-        """Generate with DistilGPT2 - simple and fast"""
+        """Generate with DistilGPT2"""
         try:
-            # Better prompt format for DistilGPT2
-            formatted_prompt = f"Fashion advice: {prompt}\n\nAnswer:"
-            
+            # Simple, direct prompt - no special formatting
             logger.info(f"    → Generating (max_tokens={max_new_tokens})")
             
             out = llm_client(
-                formatted_prompt,
+                prompt,
                 max_new_tokens=max_new_tokens,
                 temperature=temperature,
                 do_sample=True,
                 return_full_text=False,
-                repetition_penalty=1.2,  # Prevent repetition
-                no_repeat_ngram_size=3,  # Prevent repeating 3-grams
-                top_k=50,
-                top_p=0.95,
+                repetition_penalty=1.3,  # Strong penalty against repetition
+                no_repeat_ngram_size=2,  # Prevent repeating 2-grams
+                top_k=40,
+                top_p=0.9,
                 pad_token_id=llm_client.tokenizer.eos_token_id,
                 eos_token_id=llm_client.tokenizer.eos_token_id
             )
@@ -661,15 +659,11 @@ def generate_llm_answer(
             
             generated = out[0].get('generated_text', '').strip()
             
-            # Remove prompt if present
-            if "Answer:" in generated:
-                generated = generated.split("Answer:")[-1].strip()
-            
             # Clean up bad patterns
             import re
-            # Remove patterns like "A: B: C:" or "I: I: I:"
-            generated = re.sub(r'\b([A-Z]):\s*\1:\s*', '', generated)
+            # Remove nonsensical patterns like "A: B: C:" or single letters
             generated = re.sub(r'\b[A-Z]:\s*(?=[A-Z]:)', '', generated)
+            generated = re.sub(r'^[A-Z]:\s*', '', generated)  # Remove leading letters
             generated = generated.strip()
             
             word_count = len(generated.split())
@@ -680,21 +674,20 @@ def generate_llm_answer(
             logger.error(f"    ✗ Error: {e}")
             return ''
 
-    # Better prompt format with context
-    base_prompt = f"""Question: {query}
+    # Simple, natural prompt that DistilGPT2 can handle
+    base_prompt = f"""For the question "{query}", here is helpful fashion advice:
 
-Context from fashion knowledge base:
-{context_text[:400]}
+{context_text[:300]}
 
-Based on the above information, here is detailed fashion advice:"""
+To summarize:"""
 
-    # DistilGPT2 parameters - adjusted for better quality
+    # DistilGPT2 parameters - lower temperature for more coherent output
     if attempt == 1:
-        max_new_tokens = 150
-        temperature = 0.7
+        max_new_tokens = 120
+        temperature = 0.6
     else:
-        max_new_tokens = 200
-        temperature = 0.75
+        max_new_tokens = 150
+        temperature = 0.65
 
     logger.info(f"  → Starting generation with prompt: {base_prompt[:200]}...")
     initial_output = call_model(base_prompt, max_new_tokens, temperature)
@@ -823,17 +816,22 @@ def generate_answer_langchain(
     if not retrieved_docs:
         return "I couldn't find relevant information to answer your question."
     
-    # Use extractive answer as PRIMARY method - reliable and high-quality
-    # Small LLMs (DistilGPT2) produce nonsensical output on CPU
-    logger.info("  → Using extractive answer generator (primary method)")
-    try:
-        extractive_answer = generate_extractive_answer(query, retrieved_docs)
-        if extractive_answer:
-            logger.info("  ✅ Extractive answer generated successfully")
-            return extractive_answer
-    except Exception as e:
-        logger.error(f"  ✗ Extractive answer error: {e}")
+    # Try LLM generation with multiple attempts
+    max_attempts = 2
     
+    llm_answer = None
+    for attempt in range(1, max_attempts + 1):
+        logger.info(f"\n  🤖 LLM Generation Attempt {attempt}/{max_attempts}")
+        llm_answer = generate_llm_answer(query, retrieved_docs, llm_client, attempt)
+        
+        if llm_answer:
+            logger.info(f"  ✅ LLM answer generated successfully")
+            return llm_answer
+        else:
+            if attempt < max_attempts:
+                logger.warning(f"  → Attempt {attempt}/{max_attempts} failed, retrying...")
+    
+    logger.error(f"  ✗ All {max_attempts} LLM attempts failed")
     return "I apologize, but I'm having trouble generating a response. Please try rephrasing your question or ask something else."
 
 # ============================================================================
@@ -860,12 +858,17 @@ def fashion_chatbot(message: str, history: List[List[str]]):
         
         yield f"💭 Generating answer ({len(retrieved_docs)} sources found)..."
         
-        # Use extractive answer - reliable and high-quality
-        logger.info("  → Generating extractive answer")
-        llm_answer = generate_extractive_answer(message.strip(), retrieved_docs)
+        # Generate with LLM
+        llm_answer = None
+        for attempt in range(1, 3):
+            logger.info(f"\n  🤖 LLM Generation Attempt {attempt}/2")
+            llm_answer = generate_llm_answer(message.strip(), retrieved_docs, llm_client, attempt)
+            
+            if llm_answer:
+                break
         
         if not llm_answer:
-            logger.error(f"  ✗ Extractive answer generation failed")
+            logger.error(f"  ✗ All LLM attempts failed")
             yield "I apologize, but I'm having trouble generating a response. Please try rephrasing your question."
             return