llm corrected

app/ads1/ads_analyst.py

@@ -145,54 +145,59 @@ def rule_based_insights(context: dict) -> str:
     bullets: list[str] = []
 
     if c["leads"] == 0:
-        bullets.append("- No conversions recorded — review targeting, landing page, and conversion tracking.")
+        bullets.append("- No conversions recorded - review targeting, landing page, and conversion tracking.")
     elif c["cpl"] > TARGET_CPL:
         bullets.append(
-            f"- CPL is ${c['cpl']:.2f}, above the ${TARGET_CPL:.0f} target — tighten bids on expensive terms."
+            f"- CPL is ${c['cpl']:.2f}, above the ${TARGET_CPL:.0f} target - tighten bids on expensive terms."
         )
     else:
-        bullets.append(f"- CPL is ${c['cpl']:.2f} with {c['leads']} leads — performance is within a workable range.")
+        bullets.append(f"- CPL is ${c['cpl']:.2f} with {c['leads']} leads - performance is within a workable range.")
 
     if trend["spend_change_pct"] > 10 and trend["clicks_change_pct"] < trend["spend_change_pct"]:
-        bullets.append("- Spend is rising faster than clicks — efficiency is slipping; audit keyword bids.")
+        bullets.append("- Spend is rising faster than clicks - efficiency is slipping; audit keyword bids.")
 
     if signals["wasted_spend_ratio"] > 0.2:
         bullets.append(
-            f"- About {signals['wasted_spend_ratio'] * 100:.0f}% of keywords have zero conversions — pause or cut budget there."
+            f"- About {signals['wasted_spend_ratio'] * 100:.0f}% of keywords have zero conversions - pause or cut budget there."
         )
 
     for row in drivers.get("best_keywords", [])[:1]:
         bullets.append(
-            f"- '{row['keyword']}' is a top performer ({row['conversions']} conversions) — consider scaling budget."
+            f"- '{row['keyword']}' is a top performer ({row['conversions']} conversions) - consider scaling budget."
         )
 
     for row in drivers.get("worst_keywords", [])[:1]:
         if row.get("conversions", 0) == 0:
-            bullets.append(f"- '{row['keyword']}' spent without converting — reduce bids or pause.")
+            bullets.append(f"- '{row['keyword']}' spent without converting - reduce bids or pause.")
 
     if len(bullets) < 3:
-        bullets.append(f"- CTR is {c['ctr']:.2f}% across {c['impressions']:,} impressions — test stronger ad copy if CTR is low.")
+        bullets.append(f"- CTR is {c['ctr']:.2f}% across {c['impressions']:,} impressions - test stronger ad copy if CTR is low.")
 
     return "\n\n".join(bullets[:5])
 
 
 def run_ads_analyst_card(dfs: dict, campaign_name: str | None = None) -> str:
-    print("\n🚀 [analyst_card] STARTED", flush=True)
+    print("\nSTART [analyst_card] STARTED", flush=True)
 
     if not dfs:
-        return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
+        return "WARNING: No campaign data - select a campaign on the Dashboard tab first."
 
     scoped = _dfs_for_campaign(dfs, campaign_name)
     context = build_ads_analyst_context(scoped, campaign_name)
-    print("🧠 [analyst_card] context built", flush=True)
+    print("CONTEXT [analyst_card] context built", flush=True)
 
     prompt = build_ads_analyst_prompt(context)
-    print("✍️ [analyst_card] prompt built", flush=True)
+    print("PROMPT [analyst_card] prompt built", flush=True)
 
     result = generate_explanation(prompt)
+    print(f"[analyst_card] raw/clean LLM result preview: {str(result)[:400]}", flush=True)
+    if "Analysis failed:" in str(result):
+        print("[analyst_card] LLM call failed; returning the backend error instead of hiding it.", flush=True)
+        return result
+
     if is_bad_llm_output(result):
-        print("⚠️ [analyst_card] LLM fallback — using rule-based insights", flush=True)
+        print("WARNING [analyst_card] LLM fallback - using rule-based insights", flush=True)
         result = rule_based_insights(context)
 
-    print("\n📤 [analyst_card] LLM result received", flush=True)
+    print("\nRESULT [analyst_card] LLM result received", flush=True)
     return result

app/ads1/keyword_inspector.py

@@ -22,6 +22,15 @@ def build_keyword_features(df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
+def prepare_keyword_context_df(df: pd.DataFrame, max_rows: int = 20) -> pd.DataFrame:
+    winners = df[df["conversions"] > 0].sort_values(["conversions", "cpa"], ascending=[False, True]).head(10)
+    waste = df[df["conversions"] == 0].sort_values("cost", ascending=False).head(10)
+    out = pd.concat([waste, winners], ignore_index=True)
+    if "keyword" in out.columns:
+        out = out.drop_duplicates(subset=["keyword"])
+    return out.head(max_rows)
+
+
 # -------------------------
 # Prompt (simplified + stronger reasoning)
 # -------------------------
@@ -29,14 +38,40 @@ def build_keyword_prompt(context: dict) -> str:
     payload = json.dumps(context, indent=2, default=str)
 
     return keyword_inspector_prompt(payload)
+
+
+def rule_based_keyword_actions(context: dict) -> str:
+    rows = context.get("keywords", [])
+    if not rows:
+        return "- No keyword action found because no usable keyword rows were available."
+
+    bullets = []
+    for row in rows[:5]:
+        keyword = row.get("keyword", "this keyword")
+        cost = row.get("cost", 0)
+        clicks = row.get("clicks", 0)
+        conversions = row.get("conversions", 0)
+        ctr = row.get("ctr", 0)
+        cpa = row.get("cpa", 0)
+        if conversions > 0:
+            bullets.append(
+                f"- Treat '{keyword}' as a winning or scaling keyword because it produced {conversions} conversions at CPA {cpa:.2f} and CTR {ctr:.2f}%."
+            )
+        else:
+            bullets.append(
+                f"- Reduce or pause '{keyword}' because it spent {cost:.2f} across {clicks} clicks with 0 conversions."
+            )
+    return "\n\n".join(bullets)
+
+
 # -------------------------
 # Main runner
 # -------------------------
 def run_keyword_inspector(dfs: dict, campaign_name: str | None = None) -> str:
-    print("\n🚀 [keyword_inspector] STARTED", flush=True)
+    print("\nSTART [keyword_inspector] STARTED", flush=True)
 
     if not dfs or "keywords" not in dfs:
-        return "⚠️ No keyword data available."
+        return "WARNING: No keyword data available."
 
     df = dfs["keywords"].copy()
     df = build_keyword_features(df)
@@ -45,24 +80,33 @@ def run_keyword_inspector(dfs: dict, campaign_name: str | None = None) -> str:
     if campaign_name and "campaign_name" in df.columns:
         df = df[df["campaign_name"] == campaign_name]
 
+    df = prepare_keyword_context_df(df)
+    keep_cols = [
+        col
+        for col in ["keyword", "cost", "clicks", "impressions", "conversions", "ctr", "cpa"]
+        if col in df.columns
+    ]
+
     context = {
         "campaign_name": campaign_name,
-        "keywords": df.to_dict("records")  # FULL DATA given to LLM
+        "keywords": df[keep_cols].round(2).to_dict("records")
     }
 
-    print("🧠 [keyword_inspector] context built", flush=True)
+    print("CONTEXT [keyword_inspector] context built", flush=True)
 
     prompt = build_keyword_prompt(context)
-    print("✍️ [keyword_inspector] prompt built", flush=True)
+    print("PROMPT [keyword_inspector] prompt built", flush=True)
 
     result = generate_explanation(prompt)
+    print(f"[keyword_inspector] raw/clean LLM result preview: {str(result)[:400]}", flush=True)
+    if "Analysis failed:" in str(result):
+        print("[keyword_inspector] LLM call failed; returning the backend error instead of hiding it.", flush=True)
+        return result
+
 
-    if is_bad_llm_output(result):
-        print("⚠️ [keyword_inspector] LLM fallback triggered", flush=True)
-        return (
-            "- Unable to generate LLM insights right now.\n"
-            "- Check keyword data quality or retry."
-        )
+    if is_bad_llm_output(result) or not result.strip().startswith("-"):
+        print("WARNING [keyword_inspector] LLM fallback triggered", flush=True)
+        return rule_based_keyword_actions(context)
 
-    print("📤 [keyword_inspector] result received", flush=True)
+    print("RESULT [keyword_inspector] result received", flush=True)
     return result

app/recs/generate.py

@@ -57,9 +57,11 @@ def _looks_like_garbage(text: str) -> bool:
 
 
 def is_fallback_output(text: str) -> bool:
+    lower = (text or "").lower()
     return (
         not text
-        or text.startswith("⚠️")
+        or lower.startswith("warning:")
+        or "analysis failed:" in lower
         or text.startswith("This recommendation was generated")
     )
 
@@ -74,7 +76,7 @@ def sanitize_explanation(text: str, rec: Dict | None = None) -> str:
 
     bullets: list[str] = []
     for ln in lines:
-        if re.match(r"^[-•*]\s+\S", ln):
+        if re.match(r"^[-*]\s+\S", ln):
             bullets.append(ln)
         elif re.match(r"^\d+\.\s+\S", ln):
             bullets.append(re.sub(r"^\d+\.\s+", "- ", ln))
@@ -89,14 +91,13 @@ def sanitize_explanation(text: str, rec: Dict | None = None) -> str:
 
 
 def _messages_to_prompt(messages: list[dict[str, str]]) -> str:
-    chunks: list[str] = []
-    for msg in messages:
-        role = msg["role"]
-        content = msg["content"]
-        chunks.append(f"<|im_start|>{role}\n{content}{_IM_END}\n")
-    chunks.append("<|im_start|>assistant\n")
-    return "".join(chunks)
-
+    system = next((msg["content"] for msg in messages if msg["role"] == "system"), "")
+    user = next((msg["content"] for msg in messages if msg["role"] == "user"), "")
+    return (
+        f"{system}\n\n"
+        f"Request:\n{user}\n\n"
+        "Answer with only the final bullet points:\n"
+    )
 
 def _message_text(message: dict) -> str:
     content = (message.get("content") or "").strip()
@@ -109,21 +110,24 @@ def _message_text(message: dict) -> str:
 def _infer(llm, messages: list[dict[str, str]]) -> str:
     max_tokens = int(os.getenv("LLAMA_MAX_TOKENS", "384"))
     temperature = float(os.getenv("LLAMA_TEMPERATURE", "0.35"))
-
-    try:
-        out = llm.create_chat_completion(
-            messages=messages,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        )
-        raw = _message_text(out["choices"][0]["message"])
-        if raw and not _looks_like_garbage(raw):
-            print("✅ [generate_explanation] via create_chat_completion", flush=True)
-            return raw
-        print("⚠️ [generate_explanation] chat_completion empty/garbage — raw fallback", flush=True)
-    except TypeError as exc:
-        print(f"⚠️ [generate_explanation] chat_completion failed: {exc}", flush=True)
-
+    use_chat_completion = os.getenv("LLAMA_USE_CHAT_COMPLETION", "0") == "1"
+
+    if use_chat_completion:
+        try:
+            out = llm.create_chat_completion(
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+            raw = _message_text(out["choices"][0]["message"])
+            if raw and not _looks_like_garbage(raw):
+                print("OK [generate_explanation] via create_chat_completion", flush=True)
+                return raw
+            print("WARNING [generate_explanation] chat_completion empty/garbage - raw fallback", flush=True)
+        except Exception as exc:
+            print(f"WARNING [generate_explanation] chat_completion failed - raw fallback: {repr(exc)}", flush=True)
+
+    print("LLM [generate_explanation] using raw llama prompt", flush=True)
     out = llm(
         _messages_to_prompt(messages),
         max_tokens=max_tokens,
@@ -145,12 +149,12 @@ def _coerce_prompt(prompt: str | Dict, rec: Dict | None) -> tuple[str, Dict | No
 
 
 def generate_explanation(prompt: str | Dict, rec: Dict | None = None, stream: bool = False):
-    print("\n🔥 [generate_explanation] CALLED", flush=True)
+    print("\nLLM [generate_explanation] CALLED", flush=True)
 
     try:
         user_content, rec = _coerce_prompt(prompt, rec)
         print(
-            f"🧾 [generate_explanation] prompt type={type(prompt).__name__} "
+            f"PROMPT [generate_explanation] prompt type={type(prompt).__name__} "
             f"len={len(user_content)}",
             flush=True,
         )
@@ -164,27 +168,28 @@ def generate_explanation(prompt: str | Dict, rec: Dict | None = None, stream: bo
 
         with _infer_lock:
             llm = load_model()
-            print("🧠 [generate_explanation] model loaded", flush=True)
-            print("🚀 [generate_explanation] calling LLM...", flush=True)
+            print("MODEL [generate_explanation] model loaded", flush=True)
+            print("LLM [generate_explanation] calling LLM...", flush=True)
             raw = _infer(llm, messages)
 
-        print("📡 [generate_explanation] response received", flush=True)
-        print("📄 [generate_explanation] raw output length:", len(raw), flush=True)
+        print("LLM [generate_explanation] response received", flush=True)
+        print("RAW [generate_explanation] raw output length:", len(raw), flush=True)
         if raw:
-            print("📄 [generate_explanation] raw preview:", raw[:400], flush=True)
+            print("RAW [generate_explanation] raw preview:", raw[:400], flush=True)
 
         clean = sanitize_explanation(raw, rec)
         if is_bad_llm_output(clean):
             clean = fallback_explanation(rec)
-        print("✨ [generate_explanation] cleaned output ready", flush=True)
+        print("OK [generate_explanation] cleaned output ready", flush=True)
         if stream:
             return iter([clean])
         return clean
 
     except Exception as e:
-        print("❌ [generate_explanation] ERROR:", repr(e), flush=True)
+        print("ERROR [generate_explanation] ERROR:", repr(e), flush=True)
         traceback.print_exc()
-        err = f"⚠️ Analysis failed: {e}"
+        err = f"WARNING: Analysis failed: {e}"
         if stream:
             return iter([err])
         return err
+