original llm.py and generate.py restored

app/models/llm.py

@@ -2,37 +2,68 @@ from __future__ import annotations
 
 import os
 import threading
-from typing import Any
 
 from huggingface_hub import hf_hub_download
+from llama_cpp import Llama
 
-HF_REPO = os.getenv("LLAMA_HF_REPO", "ps1811/advisor-minicpm-finetuned-gguf")
-HF_FILENAME = os.getenv("LLAMA_HF_FILENAME", "advisor-minicpm-q4_k_m.gguf")
+HF_REPO = os.getenv("LLAMA_HF_REPO", "openbmb/MiniCPM5-1B-GGUF")
+HF_FILENAME = os.getenv("LLAMA_HF_FILENAME", "MiniCPM5-1B-Q4_K_M.gguf")
 
-_model: Any = None
+_model: Llama | None = None
 _init_lock = threading.Lock()
 
 
-def load_model() -> Any:
+def _preload_cuda_libs() -> None:
+    try:
+        import ctypes
+
+        import nvidia.cublas
+        import nvidia.cuda_runtime
+    except ImportError:
+        return
+
+    for module, lib_name in (
+        (nvidia.cublas, "libcublas.so.12"),
+        (nvidia.cuda_runtime, "libcudart.so.12"),
+    ):
+        lib_path = os.path.join(module.__path__[0], "lib", lib_name)
+        if os.path.isfile(lib_path):
+            ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL)
+
+
+def load_model() -> Llama:
     global _model
+    print("🧠 [load_model] called", flush=True)
 
     if _model is not None:
+        print("🧠 [load_model] returning cached model", flush=True)
         return _model
 
     with _init_lock:
         if _model is not None:
             return _model
 
+        print("⬇️ [load_model] downloading model...", flush=True)
         model_path = hf_hub_download(repo_id=HF_REPO, filename=HF_FILENAME)
+        print(f"✅ [load_model] model downloaded at {model_path}", flush=True)
 
-        from llama_cpp import Llama
+        _preload_cuda_libs()
+        gpu_layers = int(os.getenv("LLAMA_GPU_LAYERS", "-1"))
+        n_ctx = int(os.getenv("LLAMA_N_CTX", "2048"))
+        n_threads = int(os.getenv("LLAMA_N_THREADS", "4"))
+        print(
+            f"🚀 [load_model] initializing Llama "
+            f"(n_gpu_layers={gpu_layers}, n_ctx={n_ctx}, n_threads={n_threads})",
+            flush=True,
+        )
 
         _model = Llama(
             model_path=model_path,
-            n_ctx=int(os.getenv("LLAMA_N_CTX", "2048")),
-            n_gpu_layers=int(os.getenv("LLAMA_GPU_LAYERS", "0")),
-            n_threads=int(os.getenv("LLAMA_N_THREADS", "4")),
-            verbose=os.getenv("LLAMA_VERBOSE", "0") == "1",
+            n_ctx=n_ctx,
+            n_gpu_layers=gpu_layers,
+            n_threads=n_threads,
+            verbose=False,
         )
+        print("✅ [load_model] model initialized", flush=True)
 
     return _model

app/recs/generate.py

@@ -11,8 +11,18 @@ from app.models.llm import load_model
 
 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."
@@ -20,7 +30,12 @@ def fallback_explanation(rec: Dict | None = None) -> str:
 
 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)
+    text = re.sub(
+        r"<think>.*?</think>",
+        "",
+        text,
+        flags=re.DOTALL | re.IGNORECASE,
+    )
     return text.strip()
 
 
@@ -32,15 +47,20 @@ def _looks_like_garbage(text: str) -> bool:
         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)
-    bullet_count = sum(1 for ln in text.splitlines() if ln.strip().startswith("-"))
-    return digit_ratio > 0.35 and bullet_count < 2
+    return digit_ratio > 0.22
 
 
 def is_fallback_output(text: str) -> bool:
-    return not text or text.startswith("WARNING:") or text.startswith("This recommendation was generated")
+    return (
+        not text
+        or text.startswith("⚠️")
+        or text.startswith("This recommendation was generated")
+    )
 
 
 def is_bad_llm_output(text: str) -> bool:
@@ -53,7 +73,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))
@@ -67,6 +87,52 @@ def sanitize_explanation(text: str, rec: Dict | None = None) -> str:
     return flat
 
 
+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)
+
+
+def _message_text(message: dict) -> str:
+    content = (message.get("content") or "").strip()
+    reasoning = (message.get("reasoning_content") or "").strip()
+    if content and reasoning and _looks_like_garbage(content):
+        return reasoning
+    return content or reasoning
+
+
+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(
+        _messages_to_prompt(messages),
+        max_tokens=max_tokens,
+        temperature=temperature,
+        stop=_STOP_SEQUENCES,
+        echo=False,
+    )
+    return (out["choices"][0].get("text") or "").strip()
+
+
 def _coerce_prompt(prompt: str | Dict, rec: Dict | None) -> tuple[str, Dict | None]:
     if isinstance(prompt, dict):
         rec = rec or prompt
@@ -78,31 +144,46 @@ 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)
+
     try:
         user_content, rec = _coerce_prompt(prompt, rec)
+        print(
+            f"🧾 [generate_explanation] prompt type={type(prompt).__name__} "
+            f"len={len(user_content)}",
+            flush=True,
+        )
         if "/no_think" not in user_content:
             user_content = f"{user_content}\n/no_think"
 
+        messages = [
+            {"role": "system", "content": _SYSTEM},
+            {"role": "user", "content": user_content},
+        ]
+
         with _infer_lock:
             llm = load_model()
-            out = llm(
-                user_content,
-                max_tokens=int(os.getenv("LLAMA_MAX_TOKENS", "384")),
-                temperature=float(os.getenv("LLAMA_TEMPERATURE", "0.35")),
-                stop=["</s>"],
-                echo=False,
-            )
-
-        raw = (out["choices"][0].get("text") or "").strip()
-        clean = sanitize_explanation(raw, rec)
+            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 = 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()
-        err = f"WARNING: Analysis failed: {e}"
+        err = f"⚠️ Analysis failed: {e}"
         if stream:
             return iter([err])
         return err