Prompts updated

app/ads1/ads_analyst.py

@@ -134,9 +134,14 @@ def build_ads_analyst_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 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}"
+        f"Write 3 to 5 executive Google Ads recommendations for {name}.\n"
+        "Return only markdown bullets. Start every line with '- '.\n"
+        "Each bullet must follow this exact pattern:\n"
+        "- <finding> — Evidence: <specific metric from data> — Action: <specific next step>\n"
+        "Do not restate the campaign name, raw data, prompt, task, or JSON keys.\n"
+        "Do not think aloud. Do not say what you can calculate. Do not invent causes.\n"
+        "If leads are 0, focus on conversion tracking, landing-page quality, and wasted spend risk.\n\n"
+        f"Data:\n{payload}"
     )
 
 

app/ads1/budget_optimizer.py

@@ -28,12 +28,16 @@ def build_budget_optimizer_context(dfs: dict, campaign_name: str | None = None):
 
     df = build_budget_features(df)
 
-    # Keep top variance slice (NOT rule-based, just signal control)
-    df = df.sort_values("cost", ascending=False).head(200)
+    keep_cols = [
+        col
+        for col in ["name", "cost", "clicks", "impressions", "conversions", "ctr", "cpa", "cpc", "conv_per_cost"]
+        if col in df.columns
+    ]
+    df = df.sort_values(["conversions", "conv_per_cost", "cost"], ascending=[False, False, False]).head(15)
 
     return {
         "campaign_name": campaign_name,
-        "campaigns": df.to_dict("records")
+        "campaigns": df[keep_cols].round(2).to_dict("records")
     }
 
 def build_budget_optimizer_prompt(context: dict) -> str:
@@ -64,6 +68,43 @@ def build_budget_optimizer_prompt(context: dict) -> str:
         )
     
 
+def build_budget_optimizer_prompt(context: dict) -> str:
+    payload = json.dumps(context, indent=2, default=str)
+    name = context.get("campaign_name", "this account")
+
+    return (
+        f"Write 3 to 5 budget allocation recommendations for {name}.\n"
+        "Return only markdown bullets. Start every line with '- '.\n"
+        "Each bullet must follow this exact pattern:\n"
+        "- <budget action> — Evidence: <cost, conversions, CPA/CPC/CTR from data> — Expected impact: <short outcome>\n"
+        "Use only the supplied campaign metrics. Do not repeat the prompt or data. Do not invent missing campaigns.\n"
+        "If there is only one campaign, recommend within-campaign caution instead of cross-campaign reallocation.\n\n"
+        f"Data:\n{payload}"
+    )
+
+
+def rule_based_budget_actions(context: dict) -> str:
+    rows = context.get("campaigns", [])
+    if not rows:
+        return "- Hold budget — Evidence: no campaign rows available — Expected impact: prevents blind budget changes until data sync is fixed."
+
+    bullets = []
+    for row in rows[:5]:
+        name = row.get("name") or context.get("campaign_name") or "Selected campaign"
+        cost = row.get("cost", 0)
+        conversions = row.get("conversions", 0)
+        cpa = row.get("cpa", 0)
+        if conversions > 0:
+            bullets.append(
+                f"- Protect budget on {name} — Evidence: ${cost:.2f} cost, {conversions} conversions, ${cpa:.2f} CPA — Expected impact: keeps spend on proven demand."
+            )
+        else:
+            bullets.append(
+                f"- Cap budget on {name} — Evidence: ${cost:.2f} cost and 0 conversions — Expected impact: limits wasted spend while tracking or targeting is reviewed."
+            )
+    return "\n\n".join(bullets[:5])
+
+
 def run_budget_optimizer(dfs: dict, campaign_name: str | None = None) -> str:
     print("\n🚀 [budget_optimizer] STARTED", flush=True)
 
@@ -82,10 +123,7 @@ def run_budget_optimizer(dfs: dict, campaign_name: str | None = None) -> str:
 
     if is_bad_llm_output(result):
         print("⚠️ [budget_optimizer] fallback triggered", flush=True)
-        return (
-            "- Unable to generate budget recommendations right now.\n"
-            "- Try again or check campaign data quality."
-        )
+        return rule_based_budget_actions(context)
 
     print("📤 [budget_optimizer] result received", flush=True)
-    return result
+    return result

app/ads1/growth_finder.py

@@ -28,12 +28,19 @@ def build_growth_finder_context(dfs: dict, campaign_name: str | None = None):
 
     df = build_growth_finder_features(df)
 
-    # keep high-signal subset only (not rule-based, just signal control)
-    df = df.sort_values("cost", ascending=False).head(200)
+    df = df[df["conversions"] > 0].sort_values(
+        ["efficiency_score", "conversions", "ctr"],
+        ascending=[False, False, False],
+    ).head(20)
+    keep_cols = [
+        col
+        for col in ["keyword", "cost", "clicks", "impressions", "conversions", "ctr", "cvr", "cpa", "efficiency_score"]
+        if col in df.columns
+    ]
 
     return {
         "campaign_name": campaign_name,
-        "keywords": df.to_dict("records")
+        "keywords": df[keep_cols].round(2).to_dict("records")
     }
 
 def build_growth_finder_prompt(context: dict) -> str:
@@ -41,28 +48,33 @@ def build_growth_finder_prompt(context: dict) -> str:
     name = context.get("campaign_name", "this account")
 
     return (
-        f"""
-            You are a Google Ads growth strategist.
-
-            TASK:
-            Identify ONLY data-backed scaling opportunities.
-
-            STRICT RULES:
-            - If performance is weak, DO NOT suggest scaling.
-            - Do not infer missing ad groups or structures.
-            - No generic marketing theory.
-
-            OUTPUT FORMAT:
-            - Opportunity: <keyword / segment>
-            Evidence: <CTR, conversions, CPA>
-            Why it works: <short justification>
-            Action: <scale suggestion (budget / bids / match type expansion)>
-
-            DATA:
-            {payload}
-            """
+        f"Write 3 to 5 data-backed scaling opportunities for {name}.\n"
+        "Return only markdown bullets. Start every line with '- '.\n"
+        "Each bullet must follow this exact pattern:\n"
+        "- Scale: '<keyword>' — Evidence: <conversions, CPA, CTR/CVR from data> — Action: <specific budget, bid, or match-type expansion>\n"
+        "Only recommend scaling when conversions are greater than 0. If no scalable rows exist, say '- No scaling candidate — Evidence: no converting keyword rows — Action: fix tracking or demand quality first.'\n"
+        "Use only supplied metrics. Do not infer ad groups. Do not repeat the prompt. Do not think aloud.\n\n"
+        f"Data:\n{payload}"
     )
 
+
+def rule_based_growth_actions(context: dict) -> str:
+    rows = context.get("keywords", [])
+    if not rows:
+        return "- No scaling candidate — Evidence: no converting keyword rows — Action: fix tracking or demand quality before increasing budget."
+
+    bullets = []
+    for row in rows[:5]:
+        keyword = row.get("keyword", "Unknown keyword")
+        conversions = row.get("conversions", 0)
+        cpa = row.get("cpa", 0)
+        ctr = row.get("ctr", 0)
+        bullets.append(
+            f"- Scale: '{keyword}' — Evidence: {conversions} conversions, ${cpa:.2f} CPA, {ctr:.2f}% CTR — Action: test a small bid or budget increase while monitoring CPA."
+        )
+    return "\n\n".join(bullets)
+
+
 def run_growth_finder(dfs: dict, campaign_name: str | None = None) -> str:
     print("\n🚀 [growth_finder] STARTED", flush=True)
 
@@ -81,10 +93,7 @@ def run_growth_finder(dfs: dict, campaign_name: str | None = None) -> str:
 
     if is_bad_llm_output(result):
         print("⚠️ [growth_finder] fallback triggered", flush=True)
-        return (
-            "- Unable to generate scaling opportunities right now.\n"
-            "- Try again or check data quality."
-        )
+        return rule_based_growth_actions(context)
 
     print("📤 [growth_finder] result received", flush=True)
-    return result
+    return result

app/ads1/keyword_inspector.py

@@ -47,6 +47,43 @@ def build_keyword_prompt(context: dict) -> str:
         DATA:
         {payload}
         """
+
+
+def build_keyword_prompt(context: dict) -> str:
+    payload = json.dumps(context, indent=2, default=str)
+
+    return (
+        "Write 3 to 5 keyword recommendations for a preschool Google Ads campaign.\n"
+        "Return only markdown bullets. Start every line with '- '.\n"
+        "Each bullet must follow this exact pattern:\n"
+        "- <Label>: '<keyword>' — Evidence: <clicks, cost, conversions, CTR/CPA from data> — Action: <specific bid, pause, or scale action>\n"
+        "Allowed labels: Winning, Wasted Spend, Scale, Reduce, Investigate.\n"
+        "Use only supplied keyword metrics. Do not mention ad groups if ad group data is missing. Do not think aloud.\n\n"
+        f"Data:\n{payload}"
+    )
+
+
+def rule_based_keyword_actions(context: dict) -> str:
+    bullets = []
+    for row in context.get("keywords", []):
+        keyword = row.get("keyword", "Unknown keyword")
+        cost = row.get("cost", 0)
+        clicks = row.get("clicks", 0)
+        conversions = row.get("conversions", 0)
+        cpa = row.get("cpa", 0)
+        if conversions > 0:
+            bullets.append(
+                f"- Winning: '{keyword}' — Evidence: {clicks} clicks, ${cost:.2f} cost, {conversions} conversions, ${cpa:.2f} CPA — Action: protect budget and test a modest bid increase."
+            )
+        elif cost > 0:
+            bullets.append(
+                f"- Wasted Spend: '{keyword}' — Evidence: {clicks} clicks, ${cost:.2f} cost, 0 conversions — Action: reduce bid or pause until intent is proven."
+            )
+        if len(bullets) >= 5:
+            break
+    return "\n\n".join(bullets) or "- Investigate: no keyword rows available — Evidence: no usable data — Action: verify keyword data sync."
+
+
 # -------------------------
 # Main runner
 # -------------------------
@@ -63,9 +100,21 @@ 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]
 
+    keep_cols = [
+        col
+        for col in ["keyword", "cost", "clicks", "impressions", "conversions", "ctr", "cpa"]
+        if col in df.columns
+    ]
+    winners = df[df["conversions"] > 0].sort_values(["conversions", "cpa"], ascending=[False, True]).head(8)
+    waste = df[df["conversions"] == 0].sort_values("cost", ascending=False).head(8)
+    df = pd.concat([winners, waste], ignore_index=True)
+    if "keyword" in df.columns:
+        df = df.drop_duplicates(subset=["keyword"])
+    df = df.head(20)
+
     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)
@@ -77,10 +126,7 @@ def run_keyword_inspector(dfs: dict, campaign_name: str | None = None) -> str:
 
     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."
-        )
+        return rule_based_keyword_actions(context)
 
     print("📤 [keyword_inspector] result received", flush=True)
-    return result
+    return result

app/ads1/search_term_optimizer.py

@@ -34,7 +34,13 @@ def prepare_context_df(df: pd.DataFrame, max_rows: int = 200) -> pd.DataFrame:
     Instead of semantic filtering, we just cap size for token control.
     Keeps high-variance distribution intact.
     """
-    return df.sort_values("cost", ascending=False).head(max_rows)
+    converters = df[df["conversions"] > 0].sort_values(["conversions", "cpa"], ascending=[False, True]).head(12)
+    waste = df[df["conversions"] == 0].sort_values("cost", ascending=False).head(12)
+    high_intent = df[(df["conversions"] > 0) & (df["cvr"] > 0)].sort_values("cvr", ascending=False).head(8)
+    out = pd.concat([converters, waste, high_intent], ignore_index=True)
+    if "search_term" in out.columns:
+        out = out.drop_duplicates(subset=["search_term"])
+    return out.head(max_rows)
 
 # -------------------------
 # Prompt (LLM owns all reasoning now)
@@ -66,6 +72,22 @@ def build_search_optimizer_prompt(context: dict) -> str:
             """
     )
 
+
+def build_search_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 search term optimization actions for {name}.\n"
+        "Return only markdown bullets. Start every line with '- '.\n"
+        "Each bullet must follow this exact pattern:\n"
+        "- <Category>: '<search term>' — Evidence: <cost, clicks, conversions, CPA/CVR from data> — Action: <pause, reduce bid, add as keyword, or add as negative>\n"
+        "Allowed categories: Wasted Spend, High Intent, Scale, Negative Keyword Candidate, Investigate.\n"
+        "Use only supplied search terms. Do not explain calculations. Do not repeat the prompt. Do not think aloud.\n\n"
+        f"Data:\n{payload}"
+    )
+
+
 # -------------------------
 # Context builder (FULL DATA approach)
 # -------------------------
@@ -77,13 +99,39 @@ def build_search_optimizer_context(dfs: dict, campaign_name: str | None = None):
 
     df = build_search_term_features(df)
     df = prepare_context_df(df)
+    keep_cols = [
+        col
+        for col in ["search_term", "cost", "clicks", "impressions", "conversions", "ctr", "cvr", "cpc", "cpa"]
+        if col in df.columns
+    ]
 
     return {
         "campaign_name": campaign_name,
-        "search_terms": df.to_dict("records")  # FULL dataset context (bounded)
+        "search_terms": df[keep_cols].round(2).to_dict("records")
     }
 
 
+def rule_based_search_actions(context: dict) -> str:
+    bullets = []
+    for row in context.get("search_terms", []):
+        term = row.get("search_term", "Unknown term")
+        cost = row.get("cost", 0)
+        clicks = row.get("clicks", 0)
+        conversions = row.get("conversions", 0)
+        cvr = row.get("cvr", 0)
+        if conversions > 0:
+            bullets.append(
+                f"- High Intent: '{term}' — Evidence: {clicks} clicks, ${cost:.2f} cost, {conversions} conversions, {cvr:.2f}% CVR — Action: add as keyword and test higher bid."
+            )
+        elif cost > 0:
+            bullets.append(
+                f"- Wasted Spend: '{term}' — Evidence: {clicks} clicks, ${cost:.2f} cost, 0 conversions — Action: reduce bid or add as negative if intent is poor."
+            )
+        if len(bullets) >= 5:
+            break
+    return "\n\n".join(bullets) or "- Investigate: no search terms available — Evidence: no usable rows — Action: verify search term data sync."
+
+
 # -------------------------
 # Runner
 # -------------------------
@@ -105,10 +153,7 @@ def run_search_term_optimizer(dfs: dict, campaign_name: str | None = None) -> st
 
     if is_bad_llm_output(result):
         print("⚠️ [search_term_optimizer] LLM fallback triggered", flush=True)
-        return (
-            "- Unable to generate insights right now.\n"
-            "- Try again or check data quality."
-        )
+        return rule_based_search_actions(context)
 
     print("📤 [search_term_optimizer] result received", flush=True)
-    return result
+    return result

app/recs/generate.py

@@ -18,9 +18,10 @@ _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."
+    "Reply with markdown bullets only. "
+    "Each bullet must be one short, data-backed recommendation. "
+    "Do not repeat the prompt, do not explain your reasoning process, and do not invent missing fields. "
+    "Use only the evidence supplied by the user."
 )
 
 
@@ -45,6 +46,20 @@ def _looks_like_garbage(text: str) -> bool:
     lower = text.lower()
     if "return only" in lower or "no reasoning" in lower or "no explanation" in lower:
         return True
+    echo_markers = [
+        "task:",
+        "strict rules:",
+        "output format:",
+        "focus on:",
+        "data:",
+        "we can calculate",
+        "i assume",
+        "actually,",
+        "however, the data",
+        "let's",
+    ]
+    if any(marker in lower for marker in echo_markers):
+        return True
     if "google ads analyst" in lower and text.count("-") < 2:
         return True
     if "ads performance analyst" in lower and text.count("-") < 2:
@@ -107,7 +122,7 @@ 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"))
+    temperature = float(os.getenv("LLAMA_TEMPERATURE", "0.15"))
 
     try:
         out = llm.create_chat_completion(