Works just fine tuning.

app_storefront.py

@@ -10,6 +10,32 @@ sys.path.append(os.path.join(os.path.dirname(__file__), "core"))
 from core.model import model_generate, MODEL_NAME
 from core.memory import build_prompt_from_history
 from core.storefront import load_storefront, storefront_qna, extract_products, get_rules
+from core.storefront import is_storefront_query
+
+def chat_pipeline(history, message, max_new_tokens=96, temperature=0.7, top_p=0.9):
+    # 1) Try storefront facts first
+    sf = storefront_qna(DATA, message)
+    if sf:
+        return sf
+
+    # 2) If not a storefront query, offer guided help (no LLM)
+    if not is_storefront_query(message):
+        return (
+            "I can help with the graduation storefront. Examples:\n"
+            "- Parking rules, lots opening times\n"
+            "- Attire / dress code\n"
+            "- Cap & Gown details and pickup\n"
+            "- Parking passes (multiple allowed)\n"
+            "Ask one of those, and I’ll answer directly."
+        )
+
+    # 3) Otherwise, generate with memory and hard stops
+    prompt = build_prompt_from_history(history, message, k=4)
+    gen = model_generate(prompt, max_new_tokens, temperature, top_p)
+    return clean_generation(gen)
+
+def clean_generation(text: str) -> str:
+    return (text or "").strip()
 
 # ---------------- Load data + safe fallbacks ----------------
 DATA = load_storefront()  # may be None if storefront_data.json missing/empty
@@ -42,19 +68,7 @@ else:
     VENUE_RULES = FALLBACK_VENUE
     PARKING_RULES = FALLBACK_PARKING
 
-def clean_generation(text: str) -> str:
-    return (text or "").strip()
 
-# ---------------- Chat logic ----------------
-def chat_pipeline(history, message, max_new_tokens=128, temperature=0.8, top_p=0.95):
-    # 1) Use storefront facts first (reduces hallucinations)
-    sf = storefront_qna(DATA, message)  # <-- pass DATA!
-    if sf:
-        return sf
-    # 2) Memory-aware prompt to keep context grounded
-    prompt = build_prompt_from_history(history, message, k=4)
-    gen = model_generate(prompt, max_new_tokens, temperature, top_p)
-    return clean_generation(gen)
 
 # ---------------- UI ----------------
 CSS = """
@@ -171,5 +185,28 @@ with gr.Blocks(title="Storefront Chat", css=CSS) as demo:
     health_btn.click(_health_cb, inputs=[history_state], outputs=[history_state, chat, status_md])
     caps_btn.click(_caps_cb,   inputs=[history_state], outputs=[history_state, chat])
 
+def clean_generation(text: str) -> str:
+    s = (text or "").strip()
+
+    # If the prompt contained "Assistant:", keep only what comes after the last one
+    last = s.rfind("Assistant:")
+    if last != -1:
+        s = s[last + len("Assistant:"):].strip()
+
+    # If it accidentally continued into a new "User:" or instructions, cut there
+    cut_marks = ["\nUser:", "\nYOU ARE ANSWERING", "\nProducts:", "\nVenue rules:", "\nParking rules:"]
+    cut_positions = [s.find(m) for m in cut_marks if s.find(m) != -1]
+    if cut_positions:
+        s = s[:min(cut_positions)].strip()
+
+    # Collapse repeated lines like "Yes, multiple parking passes..." spam
+    lines, out = s.splitlines(), []
+    seen = set()
+    for ln in lines:
+        # dedupe only exact consecutive repeats; keep normal conversation lines
+        if not out or ln != out[-1]:
+            out.append(ln)
+    return "\n".join(out).strip()
+
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))

core/memory.py

@@ -1,22 +1,34 @@
 # core/memory.py
+
+META_MARKERS = ("### Status:", "### Capabilities", "Status:", "Capabilities", "Model:", "Storefront JSON:")
+
+def _is_meta(s: str | None) -> bool:
+    if not s: return False
+    ss = s.strip()
+    return any(m in ss for m in META_MARKERS)
+
 def build_prompt_from_history(history, user_text, k=4) -> str:
     """
-    history is a list of [user, bot] pairs (Gradio Chatbot format).
-    Keep a compact, factual system preface to ground the model.
+    history: list[[user, bot], ...] from Gradio Chatbot.
+    Keep prompt compact; exclude meta/diagnostic messages.
     """
     lines = [
-        "System: Answer questions about the university graduation storefront using the facts below.",
-        "System: Be concise. If unsure, say what is known.",
-        "Facts:",
-        "- Cap & Gown Set (CG-SET): $59.00, tassel included; ships until 10 days before the event.",
-        "- Parking Pass (PK-1): $10.00; multiple passes allowed per student.",
-        "- Venue: formal attire recommended; no muscle shirts; no sagging pants.",
-        "- Parking: no double parking; vehicles in handicap spaces will be towed.",
+        "System: Answer questions about the university graduation storefront.",
+        "System: Be concise. If unsure, state what is known."
     ]
-    for u, b in (history or [])[-k:]:
-        if u: lines.append(f"User: {u}")
-        if b: lines.append(f"Assistant: {b}")
+
+    # Keep only the last k turns that aren't meta
+    kept = []
+    for u, b in (history or []):
+        if u and not _is_meta(u):
+            kept.append(("User", u))
+        if b and not _is_meta(b):
+            kept.append(("Assistant", b))
+    kept = kept[-(2*k):]  # up to k exchanges
+
+    for role, text in kept:
+        lines.append(f"{role}: {text}")
+
     lines.append(f"User: {user_text}")
     lines.append("Assistant:")
     return "\n".join(lines)
-

core/model.py

@@ -1,23 +1,45 @@
 # core/model.py
-import os
-from transformers import pipeline
+import re, os
+from transformers import pipeline, StoppingCriteria, StoppingCriteriaList
 
 MODEL_NAME = os.getenv("HF_MODEL_GENERATION", "distilgpt2")
-_PIPE = None
+_pipe = None
 
-def get_pipe():
-    global _PIPE
-    if _PIPE is None:
-        _PIPE = pipeline("text-generation", model=MODEL_NAME)
-    return _PIPE
+class StopOnMarkers(StoppingCriteria):
+    def __init__(self, tokenizer, stop_strs=("\nUser:", "\nSystem:", "\n###", "\nProducts:", "\nVenue rules:", "\nParking rules:")):
+        self.tokenizer = tokenizer
+        self.stop_ids = [tokenizer(s, add_special_tokens=False).input_ids for s in stop_strs]
 
-def model_generate(prompt: str, max_new_tokens=128, temperature=0.8, top_p=0.95) -> str:
-    out = get_pipe()(
+    def __call__(self, input_ids, scores, **kwargs):
+        # stop if any marker sequence just appeared at the end
+        for seq in self.stop_ids:
+            L = len(seq)
+            if L and len(input_ids[0]) >= L and input_ids[0][-L:].tolist() == seq:
+                return True
+        return False
+
+def _get_pipe():
+    global _pipe
+    if _pipe is None:
+        _pipe = pipeline("text-generation", model=MODEL_NAME)
+    return _pipe
+
+def model_generate(prompt, max_new_tokens=96, temperature=0.7, top_p=0.9):
+    pipe = _get_pipe()
+    tok = pipe.tokenizer
+
+    stop = StoppingCriteriaList([StopOnMarkers(tok)])
+
+    out = pipe(
         prompt,
         max_new_tokens=int(max_new_tokens),
         do_sample=True,
         temperature=float(temperature),
         top_p=float(top_p),
-        pad_token_id=50256,
+        repetition_penalty=1.15,          # discourages exact loops
+        no_repeat_ngram_size=3,           # blocks short repeats like "Account/Account"
+        pad_token_id=tok.eos_token_id or 50256,
+        eos_token_id=tok.eos_token_id,    # stop at EOS if model supports
+        stopping_criteria=stop,
     )
     return out[0]["generated_text"]

core/storefront.py

@@ -1,5 +1,133 @@
+# core/storefront.py
 import json, os
 
+def clean_generation(text: str) -> str:
+    s = (text or "").strip()
+
+    # Keep only text after the last "Assistant:"
+    last = s.rfind("Assistant:")
+    if last != -1:
+        s = s[last + len("Assistant:"):].strip()
+
+    # Cut at the first sign of a new turn or meta
+    cut_marks = ["\nUser:", "\nSystem:", "\n###", "\nProducts:", "\nVenue rules:", "\nParking rules:"]
+    cuts = [s.find(m) for m in cut_marks if s.find(m) != -1]
+    if cuts:
+        s = s[:min(cuts)].strip()
+
+    # Remove egregious token loops like "Account/Account/..."
+    s = re.sub(r"(?:\b([A-Z][a-zA-Z0-9_/.-]{2,})\b(?:\s*/\s*\1\b)+)", r"\1", s)
+
+    # Collapse consecutive duplicate lines
+    dedup = []
+    for ln in s.splitlines():
+        if not dedup or ln.strip() != dedup[-1].strip():
+            dedup.append(ln)
+    return "\n".join(dedup).strip()
+
+HELP_KEYWORDS = {
+    "help", "assist", "assistance", "tips", "how do i", "what can you do",
+    "graduation help", "help me with graduation", "can you help me with graduation"
+}
+
+STORE_KEYWORDS = {
+    "cap", "gown", "parking", "pass", "passes", "attire", "dress",
+    "venue", "logistics", "shipping", "pickup", "lot", "lots", "arrival", "size", "sizing"
+}
+
+def is_storefront_query(text: str) -> bool:
+    t = (text or "").lower()
+    return any(k in t for k in STORE_KEYWORDS) or any(k in t for k in HELP_KEYWORDS)
+
+def _get_lots_open_hours(data) -> int:
+    try:
+        return int(((data or {}).get("logistics") or {}).get("lots_open_hours_before") or 2)
+    except Exception:
+        return 2
+
+# Main router (drop-in)
+def storefront_qna(data, user_text: str) -> str | None:
+    """
+    Deterministic storefront answers first:
+      - single-word intents (parking / wear / passes)
+      - help/capability prompt
+      - FAQ (if you have answer_faq)
+      - explicit rules queries
+      - 'lots open' timing
+      - compact products list
+    Returns None to allow LLM fallback in your chat pipeline.
+    """
+    if not user_text:
+        return None
+    t = user_text.strip().lower()
+
+    # 1) Single-word / exact intents to avoid LLM hallucinations
+    if t in {"parking"}:
+        _, pr = get_rules(data)
+        if pr:
+            return "Parking rules:\n- " + "\n- ".join(pr)
+
+    # Map 'wear/attire' variants directly to venue rules
+    if t in {"venue", "attire", "dress", "dress code", "wear"} or "what should i wear" in t:
+        vr, _ = get_rules(data)
+        if vr:
+            return "Venue rules:\n- " + "\n- ".join(vr)
+
+    # Parking passes (multiple allowed)
+    if t in {"passes", "parking pass", "parking passes"}:
+        return "Yes, multiple parking passes are allowed per student."
+
+    # 2) Help / capability intent → deterministic guidance
+    if any(k in t for k in HELP_KEYWORDS):
+        return (
+            "I can help with the graduation storefront. Try:\n"
+            "- “What are the parking rules?”\n"
+            "- “Can I buy multiple parking passes?”\n"
+            "- “Is formal attire required?”\n"
+            "- “Where do I pick up the gown?”\n"
+            "- “When do lots open?”"
+        )
+
+    # 3) JSON-driven FAQ (if available)
+    try:
+        a = answer_faq(data, t)
+        if a:
+            return a
+    except Exception:
+        pass  # answer_faq may not exist or data may be None
+
+    # 4) Explicit rules phrasing (keeps answers tight and consistent)
+    if "parking" in t and "rule" in t:
+        _, pr = get_rules(data)
+        if pr:
+            return "Parking rules:\n- " + "\n- ".join(pr)
+
+    if ("venue" in t and "rule" in t) or "attire" in t or "dress code" in t:
+        vr, _ = get_rules(data)
+        if vr:
+            return "Venue rules:\n- " + "\n- ".join(vr)
+
+    # 5) “When do lots open?” / hours / time
+    if "parking" in t and ("hours" in t or "time" in t or "open" in t):
+        lots_open = _get_lots_open_hours(data)
+        return f"Parking lots open {lots_open} hours before the ceremony."
+
+    # 6) Product info (cap/gown/parking pass)
+    if any(k in t for k in ("cap", "gown", "parking pass", "product", "item", "price")):
+        prods = extract_products(data)
+        if prods:
+            lines = []
+            for p in prods:
+                name = p.get("name", "Item")
+                price = p.get("price", p.get("price_usd", ""))
+                notes = p.get("notes", p.get("description", ""))
+                price_str = f"${price:.2f}" if isinstance(price, (int, float)) else str(price)
+                lines.append(f"{name} — {price_str}: {notes}")
+            return "\n".join(lines)
+
+    # No deterministic match → let the caller fall back to the LLM
+    return None
+
 def _find_json():
     candidates = [
         os.path.join(os.getcwd(), "storefront_data.json"),
@@ -45,80 +173,3 @@ def extract_products(data):
 def get_rules(data):
     pol = (data or {}).get("policies", {}) or {}
     return pol.get("venue_rules", []), pol.get("parking_rules", [])
-
-def storefront_qna(data, user_text: str):
-    """
-    Lightweight rules: try exact single-word intents first, then faq,
-    then rules/products lookup. Return None to allow LLM fallback.
-    """
-    if not user_text:
-        return None
-    t = user_text.strip().lower()
-
-    # single-word catches
-    if t in {"parking"}:
-        _, pr = get_rules(data)
-        if pr: return "Parking rules:\n- " + "\n- ".join(pr)
-
-    # NEW: map 'wear' directly to venue rules to avoid LLM hallucinations
-    if t in {"venue", "attire", "dress", "dress code", "wear"} or "what should i wear" in t:
-        vr, _ = get_rules(data)
-        if vr: return "Venue rules:\n- " + "\n- ".join(vr)
-
-    if t in {"passes", "parking pass", "parking passes"}:
-        return "Yes, multiple parking passes are allowed per student."
-
-    # faq
-    a = answer_faq(data, t)
-    if a: return a
-
-    # explicit rule asks
-    if "parking" in t and "rule" in t:
-        _, pr = get_rules(data)
-        if pr: return "Parking rules:\n- " + "\n- ".join(pr)
-    if ("venue" in t and "rule" in t) or "attire" in t or "dress code" in t:
-        vr, _ = get_rules(data)
-        if vr: return "Venue rules:\n- " + "\n- ".join(vr)
-
-    # “lots open” style
-    if "parking" in t and ("hours" in t or "time" in t or "open" in t):
-        lots_open = (((data or {}).get("logistics") or {}).get("lots_open_hours_before") or 2)
-        return f"Parking lots open {lots_open} hours before the ceremony."
-
-    # products
-    if "cap" in t or "gown" in t or "parking pass" in t or "product" in t:
-        prods = extract_products(data)
-        if prods:
-            lines = []
-            for p in prods:
-                price = p["price"]
-                price_str = f"${price:.2f}" if isinstance(price, (int,float)) else str(price)
-                lines.append(f"{p['name']} — {price_str}: {p['notes']}")
-            return "\n".join(lines)
-
-    return None
-
-# app_storefront.py
-
-def clean_generation(text: str) -> str:
-    s = (text or "").strip()
-
-    # If the prompt contained "Assistant:", keep only what comes after the last one
-    last = s.rfind("Assistant:")
-    if last != -1:
-        s = s[last + len("Assistant:"):].strip()
-
-    # If it accidentally continued into a new "User:" or instructions, cut there
-    cut_marks = ["\nUser:", "\nYOU ARE ANSWERING", "\nProducts:", "\nVenue rules:", "\nParking rules:"]
-    cut_positions = [s.find(m) for m in cut_marks if s.find(m) != -1]
-    if cut_positions:
-        s = s[:min(cut_positions)].strip()
-
-    # Collapse repeated lines like "Yes, multiple parking passes..." spam
-    lines, out = s.splitlines(), []
-    seen = set()
-    for ln in lines:
-        # dedupe only exact consecutive repeats; keep normal conversation lines
-        if not out or ln != out[-1]:
-            out.append(ln)
-    return "\n".join(out).strip()