Files changed.

app.py

@@ -24,12 +24,13 @@ def run_ads_card(state):
 
         print("📦 [run_ads_card] state received", type(state), flush=True)
         dfs = state.get("full_dfs")
+        campaign_name = state.get("campaign_name")
         print("📊 [run_ads_card] extracted dfs:", type(dfs), flush=True)
 
         if not dfs:
             return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
 
-        result = run_ads_analyst_card(dfs)
+        result = run_ads_analyst_card(dfs, campaign_name=campaign_name)
         print("✅ [run_ads_card] returning result", flush=True)
         return result
     except Exception as e:
@@ -46,10 +47,11 @@ def run_budget_card(state):
             return "⚠️ Select a campaign first"
 
         dfs = state.get("full_dfs")
+        campaign_name = state.get("campaign_name")
         if not dfs:
             return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
 
-        result = run_budget_optimizer_card(dfs)
+        result = run_budget_optimizer_card(dfs, campaign_name=campaign_name)
         print("✅ [run_budget_card] returning result", flush=True)
         return result
     except Exception as e:
@@ -61,10 +63,8 @@ def startup():
     try:
         init_db()
         print("✅ DB initialized successfully", flush=True)
-        return "ok"
     except Exception as e:
         print("⚠️ DB failed:", e, flush=True)
-        return "error"
 
 
 print("🔥 STEP 2: DB init done", flush=True)
@@ -132,7 +132,7 @@ with gr.Blocks() as demo:
         fn=initial_data_load,
         outputs=[full_state, campaign_table, total_spend, total_leads, average_cpl, active_campaigns],
     )
-    demo.load(fn=startup, outputs=[])
+    demo.load(fn=startup)
 
 demo.queue()
 

app/ads1/ads_analyst.py

@@ -1,17 +1,35 @@
-import pandas as pd
-from typing import Dict
+import json
 
-from app.recs.generate import generate_explanation
+import pandas as pd
 
-TARGET_CPL = 20.0
+from app.recs.generate import TARGET_CPL, generate_explanation, is_bad_llm_output
 
 # -------------------------
 # 1. DATA BUILDERS
 # -------------------------
 
 
+def _dfs_for_campaign(dfs: dict, campaign_name: str | None) -> dict:
+    if not campaign_name:
+        return dfs
+    out = dict(dfs)
+    out["campaigns"] = dfs["campaigns"][dfs["campaigns"]["name"] == campaign_name]
+    if "keywords" in dfs and "campaign_name" in dfs["keywords"].columns:
+        out["keywords"] = dfs["keywords"][dfs["keywords"]["campaign_name"] == campaign_name]
+    return out
+
+
 def build_campaign_snapshot(dfs: dict) -> dict:
     df = dfs["campaigns"]
+    if df.empty:
+        return {
+            "spend": 0.0,
+            "clicks": 0,
+            "impressions": 0,
+            "leads": 0,
+            "ctr": 0.0,
+            "cpl": 0.0,
+        }
 
     total_spend = df["cost"].sum()
     total_clicks = df["clicks"].sum()
@@ -22,21 +40,24 @@ def build_campaign_snapshot(dfs: dict) -> dict:
     cpl = (total_spend / total_leads) if total_leads else 0
 
     return {
-        "spend": round(total_spend, 2),
+        "spend": round(float(total_spend), 2),
         "clicks": int(total_clicks),
         "impressions": int(total_impr),
         "leads": int(total_leads),
-        "ctr": round(ctr, 2),
-        "cpl": round(cpl, 2),
+        "ctr": round(float(ctr), 2),
+        "cpl": round(float(cpl), 2),
     }
 
 
 def build_simple_trend(df_hourly: pd.DataFrame) -> dict:
+    if df_hourly.empty:
+        return {"spend_change_pct": 0.0, "clicks_change_pct": 0.0, "impressions_change_pct": 0.0}
+
     df = df_hourly.copy()
     df["date"] = pd.to_datetime(df["date"])
     df = df.sort_values("date")
 
-    mid = len(df) // 2
+    mid = max(len(df) // 2, 1)
     first, second = df.iloc[:mid], df.iloc[mid:]
 
     def agg(x):
@@ -60,11 +81,13 @@ def build_simple_trend(df_hourly: pd.DataFrame) -> dict:
 
 def build_top_drivers(dfs: dict) -> dict:
     kw = dfs["keywords"].copy()
+    if kw.empty:
+        return {"best_keywords": [], "worst_keywords": []}
 
     kw["cpl"] = kw["cost"] / kw["conversions"].replace(0, 1)
 
     worst = kw.sort_values("cpl", ascending=False).head(3)
-    best = kw.sort_values("cpl", ascending=True).head(3)
+    best = kw[kw["conversions"] > 0].sort_values("cpl", ascending=True).head(3)
 
     return {
         "best_keywords": best[["keyword", "cpl", "conversions"]].to_dict("records"),
@@ -74,12 +97,14 @@ def build_top_drivers(dfs: dict) -> dict:
 
 def build_signals(dfs: dict) -> dict:
     kw = dfs["keywords"].copy()
+    if kw.empty:
+        return {"low_ctr_ratio": 0.0, "wasted_spend_ratio": 0.0}
 
     kw["ctr"] = kw["clicks"] / kw["impressions"].replace(0, 1)
 
     return {
-        "low_ctr_ratio": round((kw["ctr"] < 0.02).mean(), 2),
-        "wasted_spend_ratio": round((kw["conversions"] == 0).mean(), 2),
+        "low_ctr_ratio": round(float((kw["ctr"] < 0.02).mean()), 2),
+        "wasted_spend_ratio": round(float((kw["conversions"] == 0).mean()), 2),
     }
 
 
@@ -88,59 +113,89 @@ def build_signals(dfs: dict) -> dict:
 # -------------------------
 
 
-def build_ads_analyst_context(dfs: dict) -> dict:
-    return {
+def build_ads_analyst_context(dfs: dict, campaign_name: str | None = None) -> dict:
+    ctx = {
         "campaign": build_campaign_snapshot(dfs),
         "trend": build_simple_trend(dfs["hourly"]),
         "top_drivers": build_top_drivers(dfs),
         "signals": build_signals(dfs),
     }
+    if campaign_name:
+        ctx["campaign_name"] = campaign_name
+    return ctx
 
 
 # -------------------------
-# 3. PROMPT BUILDER
+# 3. PROMPT + FALLBACK
 # -------------------------
 
 
 def build_ads_analyst_prompt(context: dict) -> str:
-    return f"""
-You are an Ads performance analyst.
-
-Return ONLY 3–5 insights.
-No reasoning. No explanation of steps.
-
-Campaign:
-{context["campaign"]}
-
-Trend:
-{context["trend"]}
-
-Top drivers:
-{context["top_drivers"]}
-
-Signals:
-{context["signals"]}
-
-Format:
-- short bullet points only
-- Simple language, no jargon
-- Focus on actionable insights
-"""
-
-
-def run_ads_analyst_card(dfs: dict) -> str:
+    payload = json.dumps(context, indent=2, default=str)
+    name = context.get("campaign_name", "this campaign")
+    return (
+        f"Write 3 to 5 bullet points of actionable Google Ads insights for {name}.\n"
+        "Use simple language. One insight per bullet. Start each line with '- '. No intro sentence.\n\n"
+        f"Data (JSON):\n{payload}"
+    )
+
+
+def rule_based_insights(context: dict) -> str:
+    c = context["campaign"]
+    trend = context["trend"]
+    signals = context["signals"]
+    drivers = context["top_drivers"]
+    bullets: list[str] = []
+
+    if c["leads"] == 0:
+        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."
+        )
+    else:
+        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.")
+
+    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."
+        )
+
+    for row in drivers.get("best_keywords", [])[:1]:
+        bullets.append(
+            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.")
+
+    if len(bullets) < 3:
+        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)
 
     if not dfs:
         return "⚠️ No campaign data — select a campaign on the Dashboard tab first."
 
-    context = build_ads_analyst_context(dfs)
+    scoped = _dfs_for_campaign(dfs, campaign_name)
+    context = build_ads_analyst_context(scoped, campaign_name)
     print("🧠 [analyst_card] context built", flush=True)
 
     prompt = build_ads_analyst_prompt(context)
     print("✍️ [analyst_card] prompt built", flush=True)
 
     result = generate_explanation(prompt)
-    print("\n📤 [analyst_card] LLM result received", flush=True)
+    if is_bad_llm_output(result):
+        print("⚠️ [analyst_card] LLM fallback — using rule-based insights", flush=True)
+        result = rule_based_insights(context)
 
+    print("\n📤 [analyst_card] LLM result received", flush=True)
     return result

app/ads1/budget_optimizer.py

@@ -1,4 +1,7 @@
-from app.recs.generate import generate_explanation
+import json
+
+from app.recs.generate import generate_explanation, is_bad_llm_output
+
 
 def build_campaign_summary(dfs: dict) -> dict:
     df = dfs["keywords"]
@@ -6,122 +9,94 @@ def build_campaign_summary(dfs: dict) -> dict:
     total_cost = df["cost"].sum()
     total_conv = df["conversions"].sum()
 
-    avg_cpl = (
-        total_cost / total_conv
-        if total_conv > 0
-        else 0
-    )
+    avg_cpl = total_cost / total_conv if total_conv > 0 else 0
 
     return {
-        "total_spend": round(total_cost, 2),
+        "total_spend": round(float(total_cost), 2),
         "total_conversions": int(total_conv),
-        "avg_cpl": round(avg_cpl, 2),
+        "avg_cpl": round(float(avg_cpl), 2),
     }
 
+
 def build_scale_candidates(dfs: dict):
     kw = dfs["keywords"].copy()
+    if kw.empty:
+        return []
 
-    kw["cpl"] = (
-        kw["cost"] /
-        kw["conversions"].replace(0, 1)
-    )
+    kw["cpl"] = kw["cost"] / kw["conversions"].replace(0, 1)
 
-    account_avg = (
-        kw["cost"].sum() /
-        max(kw["conversions"].sum(), 1)
-    )
+    account_avg = kw["cost"].sum() / max(kw["conversions"].sum(), 1)
 
-    winners = kw[
-        (kw["conversions"] > 0)
-        & (kw["cpl"] < account_avg * 0.7)
-    ]
+    winners = kw[(kw["conversions"] > 0) & (kw["cpl"] < account_avg * 0.7)]
+    winners = winners.sort_values("conversions", ascending=False)
 
-    winners = winners.sort_values(
-        "conversions",
-        ascending=False
-    )
+    return winners.head(3)[["keyword", "ad_group_name", "cpl", "conversions"]].to_dict("records")
 
-    return winners.head(3)[[
-        "keyword",
-        "ad_group_name",
-        "cpl",
-        "conversions"
-    ]].to_dict("records")
 
 def build_cut_candidates(dfs: dict):
     kw = dfs["keywords"].copy()
+    if kw.empty:
+        return []
 
-    kw["cpl"] = (
-        kw["cost"] /
-        kw["conversions"].replace(0, 1)
-    )
+    kw["cpl"] = kw["cost"] / kw["conversions"].replace(0, 1)
 
-    account_avg = (
-        kw["cost"].sum() /
-        max(kw["conversions"].sum(), 1)
-    )
+    account_avg = kw["cost"].sum() / max(kw["conversions"].sum(), 1)
 
-    losers = kw[
-        (kw["cost"] > 0)
-        & (
-            (kw["conversions"] == 0)
-            |
-            (kw["cpl"] > account_avg * 1.5)
-        )
-    ]
+    losers = kw[(kw["cost"] > 0) & ((kw["conversions"] == 0) | (kw["cpl"] > account_avg * 1.5))]
+    losers = losers.sort_values("cost", ascending=False)
 
-    losers = losers.sort_values(
-        "cost",
-        ascending=False
-    )
+    return losers.head(3)[["keyword", "ad_group_name", "cost", "conversions", "cpl"]].to_dict("records")
 
-    return losers.head(3)[[
-        "keyword",
-        "ad_group_name",
-        "cost",
-        "conversions",
-        "cpl"
-    ]].to_dict("records")
 
-def build_budget_optimizer_context(dfs: dict):
+def _dfs_for_campaign(dfs: dict, campaign_name: str | None) -> dict:
+    if not campaign_name:
+        return dfs
+    out = dict(dfs)
+    if "keywords" in dfs and "campaign_name" in dfs["keywords"].columns:
+        out["keywords"] = dfs["keywords"][dfs["keywords"]["campaign_name"] == campaign_name]
+    return out
 
-    summary = build_campaign_summary(dfs)
 
-    return {
-        "summary": summary,
+def build_budget_optimizer_context(dfs: dict, campaign_name: str | None = None) -> dict:
+    ctx = {
+        "summary": build_campaign_summary(dfs),
         "scale_candidates": build_scale_candidates(dfs),
         "cut_candidates": build_cut_candidates(dfs),
     }
+    if campaign_name:
+        ctx["campaign_name"] = campaign_name
+    return ctx
+
+
+def build_budget_optimizer_prompt(context: dict) -> str:
+    payload = json.dumps(context, indent=2, default=str)
+    name = context.get("campaign_name", "this campaign")
+    return (
+        f"Write 3 to 5 bullet points on where to increase or cut budget for {name}.\n"
+        "Use simple business language. Start each line with '- '. No intro sentence.\n\n"
+        f"Data (JSON):\n{payload}"
+    )
 
-def build_budget_optimizer_prompt(context):
-
-    return f"""
-You are a Google Ads budget optimization expert.
-
-Your goal is to identify where budget should be increased and where it should be reduced.
-
-Campaign Summary:
-{context["summary"]}
-
-Best Opportunities To Scale:
-{context["scale_candidates"]}
-
-Worst Budget Drains:
-{context["cut_candidates"]}
-
-Rules:
-- Return exactly 3 to 5 bullet points.
-- Use simple business language.
-- Mention where budget should increase.
-- Mention where budget should decrease.
-- Focus on efficiency and lead generation.
-- No reasoning process.
-"""
-
-def run_budget_optimizer_card(dfs):
-
-    context = build_budget_optimizer_context(dfs)
 
+def rule_based_budget(context: dict) -> str:
+    bullets: list[str] = []
+    for row in context.get("scale_candidates", [])[:2]:
+        bullets.append(
+            f"- Increase budget on '{row['keyword']}' — {row['conversions']} conversions at CPL ${row['cpl']:.2f}."
+        )
+    for row in context.get("cut_candidates", [])[:2]:
+        if row.get("conversions", 0) == 0:
+            bullets.append(f"- Cut spend on '{row['keyword']}' — ${row['cost']:.2f} spent with no conversions.")
+        else:
+            bullets.append(f"- Reduce budget on '{row['keyword']}' — CPL ${row['cpl']:.2f} is above average.")
+    if not bullets:
+        bullets.append("- Review keyword-level spend and shift budget toward terms with the lowest CPL.")
+    return "\n\n".join(bullets[:5])
+
+
+def run_budget_optimizer_card(dfs, campaign_name: str | None = None):
+    scoped = _dfs_for_campaign(dfs, campaign_name)
+    context = build_budget_optimizer_context(scoped, campaign_name)
     prompt = build_budget_optimizer_prompt(context)
 
     rec = {
@@ -131,4 +106,8 @@ def run_budget_optimizer_card(dfs):
         "reason": prompt,
     }
 
-    return generate_explanation(prompt, rec=rec)
+    result = generate_explanation(prompt, rec=rec)
+    if is_bad_llm_output(result):
+        print("⚠️ [budget_optimizer] LLM fallback — using rule-based budget tips", flush=True)
+        result = rule_based_budget(context)
+    return result

app/models/llm.py

@@ -44,10 +44,7 @@ def load_model() -> Llama:
             return _model
 
         print("⬇️ [load_model] downloading model...", flush=True)
-        model_path = hf_hub_download(
-            repo_id=HF_REPO,
-            filename=HF_FILENAME,
-        )
+        model_path = hf_hub_download(repo_id=HF_REPO, filename=HF_FILENAME)
         print(f"✅ [load_model] model downloaded at {model_path}", flush=True)
 
         _preload_cuda_libs()

app/recs/generate.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import json
 import os
 import re
+import threading
 import traceback
 from typing import Dict
 
@@ -12,16 +14,77 @@ TARGET_CPL = 20.0
 _IM_END = "<|im_end|>"
 _STOP_SEQUENCES = [_IM_END, "<|im_start|>", "</s>"]
 
+_infer_lock = threading.Lock()
+
+_SYSTEM = (
+    "You are a Google Ads analyst. "
+    "Reply with 3 to 5 markdown bullet points only. "
+    "Each bullet must be one short, actionable insight about the campaign data. "
+    "No introduction, no numbered lists, no step-by-step reasoning."
+)
+
 
 def fallback_explanation(rec: Dict | None = None) -> str:
     return "This recommendation was generated from campaign performance metrics."
 
 
+def _strip_thinking(text: str) -> str:
+    text = re.sub(r"<\s*think\s*>.*?<\s*/\s*think\s*>", "", text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(
+        r"<think>.*?</think>",
+        "",
+        text,
+        flags=re.DOTALL | re.IGNORECASE,
+    )
+    return text.strip()
+
+
+def _looks_like_garbage(text: str) -> bool:
+    if not text:
+        return True
+    lower = text.lower()
+    if "return only" in lower or "no reasoning" in lower or "no explanation" in lower:
+        return True
+    if "google ads analyst" in lower and text.count("-") < 2:
+        return True
+    if "ads performance analyst" in lower and text.count("-") < 2:
+        return True
+    if re.search(r"(?:\d[\s\n]+){6,}", text):
+        return True
+    digit_ratio = sum(ch.isdigit() for ch in text) / max(len(text), 1)
+    return digit_ratio > 0.22
+
+
+def is_fallback_output(text: str) -> bool:
+    return (
+        not text
+        or text.startswith("⚠️")
+        or text.startswith("This recommendation was generated")
+    )
+
+
+def is_bad_llm_output(text: str) -> bool:
+    return is_fallback_output(text) or _looks_like_garbage(text)
+
+
 def sanitize_explanation(text: str, rec: Dict | None = None) -> str:
-    cleaned = re.sub(r"\s+", " ", text).strip()
-    if not cleaned or len(cleaned) < 10:
+    text = _strip_thinking(text)
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+
+    bullets: list[str] = []
+    for ln in lines:
+        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))
+
+    if len(bullets) >= 2:
+        return "\n\n".join(bullets[:5])
+
+    flat = re.sub(r"[ \t]+", " ", text).strip()
+    if len(flat) < 20 or _looks_like_garbage(flat):
         return fallback_explanation(rec)
-    return cleaned
+    return flat
 
 
 def _messages_to_prompt(messages: list[dict[str, str]]) -> str:
@@ -34,89 +97,93 @@ def _messages_to_prompt(messages: list[dict[str, str]]) -> str:
     return "".join(chunks)
 
 
-def _strip_thinking(text: str) -> str:
-    text = re.sub(r"<\s*think\s*>.*?<\s*/\s*think\s*>", "", text, flags=re.DOTALL | re.IGNORECASE)
-    text = re.sub(
-        r"<think>.*?</think>",
-        "",
-        text,
-        flags=re.DOTALL | re.IGNORECASE,
-    )
-    return re.sub(r"\s+", " ", text).strip()
-
-
 def _message_text(message: dict) -> str:
     content = (message.get("content") or "").strip()
     reasoning = (message.get("reasoning_content") or "").strip()
-    if content and reasoning:
-        return content if len(content) >= len(reasoning) else reasoning
+    if content and reasoning and _looks_like_garbage(content):
+        return reasoning
     return content or reasoning
 
 
-def _run_completion(llm, messages: list[dict[str, str]]) -> str:
-    prompt = _messages_to_prompt(messages)
+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)
+
     out = llm(
-        prompt,
-        max_tokens=int(os.getenv("LLAMA_MAX_TOKENS", "512")),
-        temperature=0.7,
+        _messages_to_prompt(messages),
+        max_tokens=max_tokens,
+        temperature=temperature,
         stop=_STOP_SEQUENCES,
         echo=False,
     )
     return (out["choices"][0].get("text") or "").strip()
 
 
-def generate_explanation(prompt: str, rec: Dict | None = None, stream: bool = False) -> str:
+def _coerce_prompt(prompt: str | Dict, rec: Dict | None) -> tuple[str, Dict | None]:
+    if isinstance(prompt, dict):
+        rec = rec or prompt
+        reason = prompt.get("reason")
+        if reason:
+            return str(reason).strip(), rec
+        return json.dumps(prompt, default=str), rec
+    return str(prompt).strip(), rec
+
+
+def generate_explanation(prompt: str | Dict, rec: Dict | None = None, stream: bool = False):
     print("\n🔥 [generate_explanation] CALLED", flush=True)
 
     try:
+        user_content, rec = _coerce_prompt(prompt, rec)
         print(
             f"🧾 [generate_explanation] prompt type={type(prompt).__name__} "
-            f"len={len(str(prompt))}",
+            f"len={len(user_content)}",
             flush=True,
         )
-
-        llm = load_model()
-        print("🧠 [generate_explanation] model loaded", flush=True)
-
-        user_content = str(prompt).rstrip()
         if "/no_think" not in user_content:
-            user_content = f"{user_content} /no_think"
+            user_content = f"{user_content}\n/no_think"
 
         messages = [
-            {
-                "role": "system",
-                "content": "You are an expert marketing analyst. Output only the final answer.",
-            },
+            {"role": "system", "content": _SYSTEM},
             {"role": "user", "content": user_content},
         ]
 
-        print("🚀 [generate_explanation] calling LLM...", flush=True)
-        raw = _run_completion(llm, messages)
-
-        if not raw:
-            print("⚠️ [generate_explanation] raw empty — trying create_chat_completion", flush=True)
-            try:
-                out = llm.create_chat_completion(
-                    messages=messages,
-                    max_tokens=int(os.getenv("LLAMA_MAX_TOKENS", "512")),
-                    temperature=0.7,
-                )
-                raw = _message_text(out["choices"][0]["message"])
-            except TypeError as exc:
-                print(f"⚠️ [generate_explanation] chat_completion failed: {exc}", flush=True)
+        with _infer_lock:
+            llm = load_model()
+            print("🧠 [generate_explanation] model loaded", flush=True)
+            print("🚀 [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)
         if raw:
             print("📄 [generate_explanation] raw preview:", raw[:400], flush=True)
 
-        clean = _strip_thinking(raw)
-        clean = sanitize_explanation(clean, rec)
-
+        clean = sanitize_explanation(raw, rec)
+        if is_bad_llm_output(clean):
+            clean = fallback_explanation(rec)
         print("✨ [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)
         traceback.print_exc()
-        return f"⚠️ Analysis failed: {e}"
+        err = f"⚠️ Analysis failed: {e}"
+        if stream:
+            return iter([err])
+        return err

requirements.txt

@@ -1,8 +1,13 @@
 gradio>=5.0.0
-sqlalchemy      # for wat is this ?
+spaces>=0.43.0
+sqlalchemy
 google-ads>=27.0.0
 pandas
-llama-cpp-python==0.2.90
-pytest
 python-dotenv
-requests
+requests
+huggingface_hub>=0.24.0
+pytest
+--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+llama-cpp-python==0.3.23
+nvidia-cuda-runtime-cu12
+nvidia-cublas-cu12