LLM-first kit planning: read use-case intent and map to in-stock categories instead of defaulting novel requests to vlogging

RAG_Products/kits.py

@@ -60,16 +60,41 @@ _KIT_TRIGGERS = [
 ]
 
 
+_KIT_WORD_RE = re.compile(
+    r"\b(kit|set ?up|bundle|package|gear|rig|complete|everything (i|you) need|build me)\b")
+
+
+def derive_kit_name(query):
+    """A human label for the kit header, read from the request.
+
+    "i need a short film making setup" -> "short film making"
+    "wildlife professional photography setup" -> "wildlife professional photography"
+    Falls back to "custom" if nothing meaningful is left.
+    """
+    q = query.lower()
+    # drop filler + the kit word itself, keep the descriptive middle
+    q = re.sub(r"\b(i|need|want|a|an|the|for|me|please|some|my|get|give|make|"
+               r"build|looking|recommend|suggest|good|best|professional|pro)\b", " ", q)
+    q = _KIT_WORD_RE.sub(" ", q)
+    q = re.sub(r"\b(under|below|upto|up to|around|within)\b.*$", " ", q)  # strip budget tail
+    q = re.sub(r"[^a-z\s]", " ", q)
+    name = " ".join(q.split()).strip()
+    return name or "custom"
+
+
 def detect_kit(query, budget=None):
     """Return (kit_name, [categories]) if the query asks for a setup, else None.
 
     Requires an explicit kit word (kit/setup/bundle/gear/rig/...) OR a budget
     alongside a kit trigger — so "best mic for an interview" is NOT a kit, while
     "interview setup" and "vlogging under 50k" are.
+
+    The returned categories are only a hint; the real planning happens in
+    plan_categories (LLM-first). When no known type is named, kit_name is read
+    from the request so the header reflects what the user actually asked for.
     """
     q = query.lower()
-    has_kit_word = bool(re.search(
-        r"\b(kit|set ?up|bundle|package|gear|rig|complete|everything (i|you) need|build me)\b", q))
+    has_kit_word = bool(_KIT_WORD_RE.search(q))
     matched = None
     for name, triggers in _KIT_TRIGGERS:
         if any(t in q for t in triggers):
@@ -78,19 +103,23 @@ def detect_kit(query, budget=None):
     if matched and (has_kit_word or budget):
         return matched, KIT_TEMPLATES[matched]
     if has_kit_word:
-        name = matched or "vlogging"
-        return name, KIT_TEMPLATES[name]
+        # unknown kit type -> let plan_categories (LLM) decide; label from query
+        return derive_kit_name(query), KIT_TEMPLATES["vlogging"]
     return None
 
 
 _LLM_PLAN_CACHE = {}
 
 
-def plan_categories_llm(query):
-    """Use the LLM to pick kit categories from the user's request.
+def plan_categories_llm(query, stock=None):
+    """Use the LLM to read the user's request and pick kit categories.
 
-    Cached per query so a repeat request is instant. Returns a validated list
-    of categories or None. The LLM chooses ONLY categories — never prices.
+    The LLM understands the *intent* (e.g. "short film", "wildlife photography",
+    "live streaming") and maps it onto the store's real, in-stock categories.
+    It chooses ONLY categories — never products or prices. Cached per query.
+
+    `stock` is the set of categories that actually have inventory; we hand it to
+    the LLM so it never plans around gear we don't carry.
     """
     from RAG_Products.models import llm_available, llm_complete
 
@@ -99,18 +128,34 @@ def plan_categories_llm(query):
     key = query.lower().strip()
     if key in _LLM_PLAN_CACHE:
         return _LLM_PLAN_CACHE[key]
+
+    choices = sorted(stock) if stock else AVAILABLE_CATEGORIES
+    # a couple of worked examples teach the model to discriminate use-cases
+    # instead of defaulting everything to a generic vlogging bundle.
     prompt = (
-        "You plan equipment kits for a photography & videography store.\n"
-        f"Choose the categories needed for this request: \"{query}\".\n"
-        f"Pick ONLY from this exact list: {AVAILABLE_CATEGORIES}.\n"
-        "Order them most-important first, at most 6.\n"
+        "You are an expert kit planner for a photography & videography store.\n"
+        "Read what the customer wants to shoot and decide which equipment "
+        "categories their kit needs. Different jobs need different gear:\n"
+        "  - a short film needs a camera, audio, lighting, support and storage\n"
+        "  - wildlife photography needs a long lens, a sturdy tripod, storage, power\n"
+        "  - live streaming needs lighting, audio, a capture/storage path\n"
+        "  - a podcast is audio-first with stands and power\n"
+        f"\nCustomer request: \"{query}\"\n\n"
+        f"Pick ONLY from these in-stock categories: {choices}.\n"
+        "Choose the 3-6 most relevant, most-important first. Do not invent "
+        "categories outside the list.\n"
         "Respond with ONLY a JSON array of category strings, nothing else."
     )
     try:
         raw = llm_complete(prompt)
         m = re.search(r"\[.*\]", raw, flags=re.DOTALL)
         cats = json.loads(m.group(0) if m else raw)
-        valid = [c for c in cats if c in AVAILABLE_CATEGORIES]
+        # keep order, validate against the real category vocabulary
+        seen, valid = set(), []
+        for c in cats:
+            if c in AVAILABLE_CATEGORIES and c not in seen:
+                seen.add(c)
+                valid.append(c)
         result = valid or None
     except Exception:
         result = None
@@ -118,34 +163,49 @@ def plan_categories_llm(query):
     return result
 
 
+def _exact_template(query):
+    """Return (name, categories) only when the query NAMES a known kit type
+    (podcast, vlogging, studio, ...). A bare "setup" with no recognised type
+    does NOT match here — that goes to the LLM so it can read the real intent.
+    """
+    q = query.lower()
+    for name, triggers in _KIT_TRIGGERS:
+        if any(t in q for t in triggers):
+            return name, KIT_TEMPLATES[name]
+    return None
+
+
 def plan_categories(query, budget=None, use_llm=True, stock=None):
-    """Decide kit categories.
+    """Decide which categories a kit needs.
 
-    TEMPLATE-FIRST: a recognised kit type (vlogging, podcast, studio, ...) uses
-    its curated template instantly — faster and higher quality than the LLM,
-    which tends to pick aspirational-but-unstocked categories. The LLM runs only
-    for novel requests with no matching template. `stock` (a set of categories
-    that actually have inventory) filters out empty picks.
+    LLM-FIRST: the model reads the request, understands the use-case, and maps
+    it onto our in-stock categories — so "short film", "wildlife photography"
+    and "live streaming" each get the right gear instead of a generic vlogging
+    bundle. Order of precedence:
+
+      1. A request that NAMES a known kit type (podcast/vlogging/studio/...) uses
+         that curated template — instant and high quality.
+      2. Otherwise the LLM plans categories from the use-case.
+      3. If the LLM is unavailable or fails, fall back to the vlogging template.
     """
-    kit = detect_kit(query, budget)
-    if kit:
-        cats = kit[1]
-        if stock:
-            cats = [c for c in cats if c in stock]
-        return cats, "template"
+    def _filt(cats):
+        return [c for c in cats if c in stock] if stock else list(cats)
+
+    # 1. named, curated kit type
+    exact = _exact_template(query)
+    if exact:
+        return _filt(exact[1]), "template"
 
+    # 2. LLM reads the intent and picks in-stock categories
     if use_llm:
-        cats = plan_categories_llm(query)
+        cats = plan_categories_llm(query, stock=stock)
         if cats:
-            if stock:
-                cats = [c for c in cats if c in stock]
+            cats = _filt(cats)
             if cats:
                 return cats, "llm"
 
-    cats = KIT_TEMPLATES["vlogging"]
-    if stock:
-        cats = [c for c in cats if c in stock]
-    return cats, "default"
+    # 3. last-resort default
+    return _filt(KIT_TEMPLATES["vlogging"]), "default"
 
 
 def _price(doc):