Add dynamic LLM provider/model selection to AI Analyst

- ai_analyst: add Groq support, _active_provider/_active_model globals,
refactored call_llm routing (Ollama → Groq → HF auto fallback),
handle Kafka 'set_llm' control message to switch provider at runtime
- dashboard: /ai/select now publishes set_llm to Kafka control topic so
the AI Analyst service picks up provider changes immediately
- dashboard + index.html: sync LLM selector UI (provider/model dropdowns,
badge, SSE llm_config event) to latest working version

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

ai_analyst/ai_analyst.py

@@ -12,8 +12,15 @@ OLLAMA_HOST    = os.getenv("OLLAMA_HOST", "")          # e.g. http://host.docker
 OLLAMA_MODEL   = os.getenv("OLLAMA_MODEL", "llama3.1:8b")
 HF_TOKEN       = os.getenv("HF_TOKEN", "")
 HF_MODEL       = os.getenv("HF_MODEL", "Qwen/Qwen2.5-7B-Instruct-1M")
+GROQ_API_KEY   = os.getenv("GROQ_API_KEY", "")
+GROQ_MODEL     = os.getenv("GROQ_MODEL", "llama-3.1-8b-instant")
+GROQ_URL       = "https://api.groq.com/openai/v1/chat/completions"
 ANALYSIS_INTERVAL = int(os.getenv("ANALYSIS_INTERVAL", "1800"))  # 30 min default
 
+# ── Runtime LLM selection (updated via Kafka "set_llm" control messages) ───────
+_active_provider = "auto"   # "auto" | "ollama" | "groq" | "hf"
+_active_model    = None     # None = use env-var default for chosen provider
+
 # ── Rolling market data buffers ────────────────────────────────────────────────
 recent_trades     = deque(maxlen=200)
 latest_snapshots  = {}          # symbol -> snapshot dict
@@ -25,69 +32,104 @@ _suspended = False
 # ── LLM call ──────────────────────────────────────────────────────────────────
 
 def call_llm(prompt: str) -> str | None:
-    """Try Ollama first, fall back to HuggingFace Inference API."""
+    """Route to the active provider (or auto-fallback chain: Ollama → Groq → HF)."""
 
-    # 1. Ollama (local)
-    if OLLAMA_HOST:
+    def _try_ollama(model):
+        if not OLLAMA_HOST:
+            return None
+        m = model or OLLAMA_MODEL
         try:
             resp = requests.post(
                 f"{OLLAMA_HOST}/api/chat",
-                json={
-                    "model":    OLLAMA_MODEL,
-                    "messages": [{"role": "user", "content": prompt}],
-                    "stream":   False,
-                },
+                json={"model": m, "messages": [{"role": "user", "content": prompt}], "stream": False},
                 timeout=90,
             )
             if resp.status_code == 200:
                 text = resp.json().get("message", {}).get("content", "").strip()
                 if text:
-                    print(f"[AI-Analyst] Insight via Ollama ({OLLAMA_MODEL})")
+                    print(f"[AI-Analyst] Insight via Ollama ({m})")
                     return text
-            else:
-                print(f"[AI-Analyst] Ollama HTTP {resp.status_code}: {resp.text[:200]}")
+            print(f"[AI-Analyst] Ollama HTTP {resp.status_code}: {resp.text[:200]}")
         except Exception as e:
-            print(f"[AI-Analyst] Ollama unreachable: {e}")
+            print(f"[AI-Analyst] Ollama error: {e}")
+        return None
 
-    # 2. HuggingFace Inference API — router.huggingface.co (OpenAI-compatible)
-    if HF_TOKEN:
+    def _try_groq(model):
+        if not GROQ_API_KEY:
+            return None
+        m = model or GROQ_MODEL
+        try:
+            resp = requests.post(
+                GROQ_URL,
+                headers={"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"},
+                json={"model": m, "messages": [{"role": "user", "content": prompt}],
+                      "max_tokens": 300, "temperature": 0.7},
+                timeout=30,
+            )
+            if resp.status_code == 200:
+                text = resp.json()["choices"][0]["message"]["content"].strip()
+                if text:
+                    print(f"[AI-Analyst] Insight via Groq ({m})")
+                    return text
+            print(f"[AI-Analyst] Groq HTTP {resp.status_code}: {resp.text[:200]}")
+        except Exception as e:
+            print(f"[AI-Analyst] Groq error: {e}")
+        return None
+
+    def _try_hf(model):
+        if not HF_TOKEN:
+            return None
+        m = model or HF_MODEL
         url = "https://router.huggingface.co/v1/chat/completions"
-        print(f"[AI-Analyst] Calling HF router: model={HF_MODEL}")
+        print(f"[AI-Analyst] Calling HF router: model={m}")
         for attempt in range(3):
             try:
                 resp = requests.post(
                     url,
-                    headers={
-                        "Authorization": f"Bearer {HF_TOKEN}",
-                        "Content-Type":  "application/json",
-                    },
-                    json={
-                        "model":       HF_MODEL,
-                        "messages":    [{"role": "user", "content": prompt}],
-                        "max_tokens":  220,
-                        "temperature": 0.7,
-                    },
+                    headers={"Authorization": f"Bearer {HF_TOKEN}", "Content-Type": "application/json"},
+                    json={"model": m, "messages": [{"role": "user", "content": prompt}],
+                          "max_tokens": 220, "temperature": 0.7},
                     timeout=60,
                 )
                 print(f"[AI-Analyst] HF response status: {resp.status_code}")
                 if resp.status_code == 200:
                     text = resp.json()["choices"][0]["message"]["content"].strip()
                     if text:
-                        print(f"[AI-Analyst] Insight via HuggingFace ({HF_MODEL})")
+                        print(f"[AI-Analyst] Insight via HuggingFace ({m})")
                         return text
                 elif resp.status_code == 503:
                     body = resp.json() if resp.content else {}
-                    wait = body.get("estimated_time", 20)
+                    wait = min(float(body.get("estimated_time", 20)), 30)
                     print(f"[AI-Analyst] HF model loading, waiting {wait:.0f}s (attempt {attempt+1}/3)")
-                    time.sleep(min(float(wait), 30))
+                    time.sleep(wait)
                 else:
                     print(f"[AI-Analyst] HF HTTP {resp.status_code}: {resp.text[:400]}")
                     break
             except Exception as e:
                 print(f"[AI-Analyst] HF API error (attempt {attempt+1}/3): {e}")
                 break
+        return None
+
+    provider = _active_provider
+    model    = _active_model
 
-    return None
+    if provider == "ollama":
+        return _try_ollama(model)
+    if provider == "groq":
+        return _try_groq(model)
+    if provider == "hf":
+        return _try_hf(model)
+
+    # Auto fallback chain
+    if OLLAMA_HOST:
+        text = _try_ollama(model)
+        if text:
+            return text
+    if GROQ_API_KEY:
+        text = _try_groq(model)
+        if text:
+            return text
+    return _try_hf(model)
 
 
 # ── Prompt builder ─────────────────────────────────────────────────────────────
@@ -166,7 +208,7 @@ def run_immediate_analysis(producer):
 # ── Kafka consumer (market data) ──────────────────────────────────────────────
 
 def consume_market_data(producer):
-    global _running, _suspended
+    global _running, _suspended, _active_provider, _active_model
     consumer = create_consumer(
         topics=[
             Config.TRADES_TOPIC,
@@ -199,6 +241,11 @@ def consume_market_data(producer):
                     _suspended = False
                 elif action == "generate_insight":
                     threading.Thread(target=run_immediate_analysis, args=(producer,), daemon=True).start()
+                elif action == "set_llm":
+                    _active_provider = msg.value.get("provider", "auto")
+                    _active_model    = msg.value.get("model") or None
+                    label = f"{_active_provider}/{_active_model}" if _active_model else _active_provider
+                    print(f"[AI-Analyst] LLM switched to: {label}")
 
 
 # ── Analysis loop ──────────────────────────────────────────────────────────────
@@ -207,10 +254,13 @@ def analysis_loop(producer):
     print(f"[AI-Analyst] Analysis loop started (interval={ANALYSIS_INTERVAL}s)")
     if OLLAMA_HOST:
         print(f"[AI-Analyst] Ollama: {OLLAMA_HOST}  model: {OLLAMA_MODEL}")
+    if GROQ_API_KEY:
+        print(f"[AI-Analyst] Groq model: {GROQ_MODEL}")
     if HF_TOKEN:
         print(f"[AI-Analyst] HuggingFace fallback: model={HF_MODEL}")
-    if not OLLAMA_HOST and not HF_TOKEN:
-        print("[AI-Analyst] WARNING: neither OLLAMA_HOST nor HF_TOKEN configured — no insights will be generated")
+    if not OLLAMA_HOST and not GROQ_API_KEY and not HF_TOKEN:
+        print("[AI-Analyst] WARNING: no LLM configured — no insights will be generated")
+    print(f"[AI-Analyst] Active provider: {_active_provider} (send Kafka 'set_llm' to change)")
 
     while True:
         time.sleep(ANALYSIS_INTERVAL)

dashboard/dashboard.py

@@ -28,7 +28,7 @@ FRONTEND_URL   = os.getenv("FRONTEND_URL",   "")
 
 # ── AI Analyst (inline LLM for on-demand generation) ───────────────────────────
 HF_TOKEN  = os.getenv("HF_TOKEN", "")
-HF_MODEL  = os.getenv("HF_MODEL", "Qwen/Qwen2.5-7B-Instruct")
+HF_MODEL  = os.getenv("HF_MODEL", "RayMelius/stockex-analyst")
 HF_URL    = "https://router.huggingface.co/v1/chat/completions"
 GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
 GROQ_MODEL   = os.getenv("GROQ_MODEL", "llama-3.1-8b-instant")
@@ -36,6 +36,25 @@ GROQ_URL     = "https://api.groq.com/openai/v1/chat/completions"
 OLLAMA_HOST  = os.getenv("OLLAMA_HOST", "")
 OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "llama3.1:8b")
 
+# Known model lists for the dynamic selector UI
+GROQ_MODELS = [
+    "llama-3.1-8b-instant",
+    "llama-3.3-70b-versatile",
+    "llama-3.1-70b-versatile",
+    "mixtral-8x7b-32768",
+    "gemma2-9b-it",
+]
+HF_MODELS = [
+    "RayMelius/stockex-analyst",
+    "Qwen/Qwen2.5-7B-Instruct-1M",
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "mistralai/Mistral-7B-Instruct-v0.3",
+]
+
+# Runtime LLM selection (overrides env var defaults when set via /ai/select)
+_active_provider = "auto"   # "auto" | "ollama" | "groq" | "hf"
+_active_model    = None     # str override or None = use env var default
+
 
 def _build_market_prompt():
     with lock:
@@ -76,91 +95,111 @@ def _build_market_prompt():
             f"Plain prose, no headers, no bullet points.")
 
 
-def _call_llm(prompt):
-    """Try Ollama first, then HuggingFace router. Returns (text, source) or (None, error_msg)."""
-    # 1. Ollama
-    if OLLAMA_HOST:
+def _call_llm(prompt, force_provider=None, force_model=None):
+    """Call LLM. Returns (text, source) or (None, error_msg).
+    force_provider: "auto"|"ollama"|"groq"|"hf"|None  — selects which provider to use.
+    force_model:    override the default model name for the chosen provider.
+    When force_provider is "auto" or None, falls back through Ollama -> Groq -> HF.
+    """
+    provider = force_provider or "auto"
+
+    def _try_ollama(model):
+        if not OLLAMA_HOST:
+            return None, "Ollama not configured (OLLAMA_HOST not set)"
+        m = model or OLLAMA_MODEL
         try:
             r = requests.post(f"{OLLAMA_HOST}/api/chat",
-                              json={"model": OLLAMA_MODEL,
-                                    "messages": [{"role": "user", "content": prompt}],
+                              json={"model": m, "messages": [{"role": "user", "content": prompt}],
                                     "stream": False},
                               timeout=90)
             if r.status_code == 200:
                 text = r.json().get("message", {}).get("content", "").strip()
                 if text:
-                    return text, "Ollama"
-            print(f"[Dashboard/LLM] Ollama {r.status_code}: {r.text[:200]}")
+                    return text, f"Ollama/{m}"
+            return None, f"Ollama HTTP {r.status_code}: {r.text[:200]}"
         except Exception as e:
-            print(f"[Dashboard/LLM] Ollama error: {e}")
+            return None, f"Ollama error: {e}"
 
-    # 2. Groq (free, fast)
-    if GROQ_API_KEY:
+    def _try_groq(model):
+        if not GROQ_API_KEY:
+            return None, "Groq not configured (GROQ_API_KEY not set)"
+        m = model or GROQ_MODEL
         try:
             r = requests.post(GROQ_URL,
                               headers={"Authorization": f"Bearer {GROQ_API_KEY}",
                                        "Content-Type": "application/json"},
-                              json={"model": GROQ_MODEL,
-                                    "messages": [{"role": "user", "content": prompt}],
-                                    "max_tokens": 180,
-                                    "temperature": 0.7},
+                              json={"model": m, "messages": [{"role": "user", "content": prompt}],
+                                    "max_tokens": 300, "temperature": 0.7},
                               timeout=30)
             print(f"[Dashboard/LLM] Groq status {r.status_code}")
             if r.status_code == 200:
                 text = r.json()["choices"][0]["message"]["content"].strip()
                 if text:
-                    return text, f"Groq/{GROQ_MODEL}"
-            else:
-                print(f"[Dashboard/LLM] Groq error: {r.text[:200]}")
-        except Exception as e:
-            print(f"[Dashboard/LLM] Groq exception: {e}")
-
-    # 3. HuggingFace router
-    if not HF_TOKEN:
-        return None, "No LLM configured. Set GROQ_API_KEY (free at console.groq.com) or HF_TOKEN."
-    print(f"[Dashboard/LLM] Calling HF router ({HF_MODEL})…")
-    for attempt in range(3):
-        try:
-            r = requests.post(HF_URL,
-                              headers={"Authorization": f"Bearer {HF_TOKEN}",
-                                       "Content-Type": "application/json"},
-                              json={"model": HF_MODEL,
-                                    "messages": [{"role": "user", "content": prompt}],
-                                    "max_tokens": 180,
-                                    "temperature": 0.7},
-                              timeout=90)
-            print(f"[Dashboard/LLM] HF status {r.status_code} (attempt {attempt+1})")
-            if r.status_code == 200:
-                text = r.json()["choices"][0]["message"]["content"].strip()
-                if text:
-                    return text, HF_MODEL
-            elif r.status_code == 503:
-                body = {}
-                try: body = r.json()
-                except: pass
-                wait = min(float(body.get("estimated_time", 20)), 30)
-                print(f"[Dashboard/LLM] Model loading, waiting {wait:.0f}s…")
-                time.sleep(wait)
-            else:
-                print(f"[Dashboard/LLM] HF error body: {r.text[:400]}")
-                try:
-                    err_code = r.json().get("error", {}).get("code", "")
-                except Exception:
-                    err_code = ""
-                if r.status_code == 402 or "credit" in r.text.lower() or "depleted" in r.text.lower():
-                    return None, ("HF credit balance depleted. Add GROQ_API_KEY secret instead "
-                                  "(free at console.groq.com — 14,400 req/day).")
-                if err_code == "model_not_supported" or "provider" in r.text.lower():
-                    return None, (f"Model '{HF_MODEL}' not available on any enabled provider. "
-                                  "Set HF_MODEL secret to a supported model (e.g. Qwen/Qwen2.5-7B-Instruct).")
-                return None, f"HF HTTP {r.status_code}: {r.text[:120]}"
-        except requests.exceptions.Timeout:
-            print(f"[Dashboard/LLM] HF timeout (attempt {attempt+1})")
-            return None, "HF request timed out after 90s"
+                    return text, f"Groq/{m}"
+            return None, f"Groq HTTP {r.status_code}: {r.text[:200]}"
         except Exception as e:
-            print(f"[Dashboard/LLM] HF exception: {e}")
-            return None, str(e)
-    return None, "HF: max retries exceeded"
+            return None, f"Groq error: {e}"
+
+    def _try_hf(model):
+        if not HF_TOKEN:
+            return None, "HuggingFace not configured (HF_TOKEN not set)"
+        m = model or HF_MODEL
+        # Use direct inference API for custom models, router for known public models
+        if m.startswith("RayMelius/") or "/" in m.split("/")[0]:
+            url = f"https://api-inference.huggingface.co/models/{m}/v1/chat/completions"
+        else:
+            url = HF_URL
+        print(f"[Dashboard/LLM] Calling HF ({m})...")
+        for attempt in range(3):
+            try:
+                r = requests.post(url,
+                                  headers={"Authorization": f"Bearer {HF_TOKEN}",
+                                           "Content-Type": "application/json"},
+                                  json={"model": m,
+                                        "messages": [{"role": "user", "content": prompt}],
+                                        "max_tokens": 300, "temperature": 0.7},
+                                  timeout=90)
+                print(f"[Dashboard/LLM] HF status {r.status_code} (attempt {attempt+1})")
+                if r.status_code == 200:
+                    text = r.json()["choices"][0]["message"]["content"].strip()
+                    if text:
+                        return text, m
+                elif r.status_code == 503:
+                    body = {}
+                    try: body = r.json()
+                    except: pass
+                    wait = min(float(body.get("estimated_time", 20)), 30)
+                    print(f"[Dashboard/LLM] Model loading, waiting {wait:.0f}s...")
+                    time.sleep(wait)
+                else:
+                    print(f"[Dashboard/LLM] HF error: {r.text[:400]}")
+                    if r.status_code == 402 or "credit" in r.text.lower() or "depleted" in r.text.lower():
+                        return None, "HF credit depleted. Add GROQ_API_KEY (free at console.groq.com)."
+                    return None, f"HF HTTP {r.status_code}: {r.text[:120]}"
+            except requests.exceptions.Timeout:
+                return None, "HF request timed out after 90s"
+            except Exception as e:
+                return None, f"HF error: {e}"
+        return None, "HF: max retries exceeded"
+
+    # Route to chosen provider or auto-fallback chain
+    if provider == "ollama":
+        return _try_ollama(force_model)
+    if provider == "groq":
+        return _try_groq(force_model)
+    if provider == "hf":
+        return _try_hf(force_model)
+
+    # Auto: Ollama -> Groq -> HF
+    if OLLAMA_HOST:
+        text, src = _try_ollama(force_model)
+        if text:
+            return text, src
+    if GROQ_API_KEY:
+        text, src = _try_groq(force_model)
+        if text:
+            return text, src
+    return _try_hf(force_model)
 
 
 def _generate_and_broadcast():
@@ -171,7 +210,7 @@ def _generate_and_broadcast():
         return
 
     prompt = _build_market_prompt()
-    text, source = _call_llm(prompt)
+    text, source = _call_llm(prompt, force_provider=_active_provider, force_model=_active_model)
     if text:
         insight = {"text": text, "source": source, "timestamp": time.time()}
         with lock:
@@ -615,6 +654,51 @@ def trigger_ai_insight():
     return jsonify({"status": "ok", "message": "Insight generation started"})
 
 
+@app.route("/ai/config")
+def ai_config():
+    """Return available providers/models and the current active selection."""
+    return jsonify({
+        "active_provider": _active_provider,
+        "active_model":    _active_model,
+        "providers": {
+            "auto":   {"label": "Auto (fallback chain)", "models": []},
+            "groq":   {"label": "Groq",                 "models": GROQ_MODELS,
+                       "available": bool(GROQ_API_KEY)},
+            "hf":     {"label": "HuggingFace",          "models": HF_MODELS,
+                       "available": bool(HF_TOKEN)},
+            "ollama": {"label": "Ollama (local)",        "models": [OLLAMA_MODEL] if OLLAMA_HOST else [],
+                       "available": bool(OLLAMA_HOST)},
+        },
+    })
+
+
+@app.route("/ai/select", methods=["POST"])
+def ai_select():
+    """Dynamically switch the LLM provider/model used for AI insights."""
+    global _active_provider, _active_model
+    data = request.get_json(force=True, silent=True) or {}
+    provider = data.get("provider", "auto")
+    model    = data.get("model") or None
+
+    allowed = {"auto", "groq", "hf", "ollama"}
+    if provider not in allowed:
+        return jsonify({"status": "error", "error": f"Unknown provider '{provider}'"}), 400
+
+    _active_provider = provider
+    _active_model    = model
+    label = f"{provider}/{model}" if model else provider
+    print(f"[Dashboard/LLM] Provider switched to: {label}")
+    broadcast_event("llm_config", {"provider": _active_provider, "model": _active_model})
+    # Propagate selection to ai_analyst service via Kafka control topic
+    try:
+        p = get_producer()
+        p.send(Config.CONTROL_TOPIC, {"action": "set_llm", "provider": provider, "model": model})
+        p.flush()
+    except Exception as e:
+        print(f"[Dashboard/LLM] Could not publish set_llm to Kafka: {e}")
+    return jsonify({"status": "ok", "provider": _active_provider, "model": _active_model})
+
+
 @app.route("/ai/debug")
 def ai_debug():
     """Synchronous LLM test — returns raw API result for debugging."""

dashboard/templates/index.html

@@ -379,14 +379,30 @@
 
   <!-- AI Analyst panel (full width) -->
   <div class="ai-panel">
-    <h2 style="margin:0 0 8px; font-size:15px; display:flex; align-items:center; gap:10px;">
+    <h2 style="margin:0 0 8px; font-size:15px; display:flex; align-items:center; gap:8px; flex-wrap:wrap;">
       AI Analyst
       <button id="ai-generate-btn" onclick="triggerAIInsight()"
               style="padding:5px 14px; background:#5c6bc0; color:#fff; border:none; border-radius:12px;
                      font-size:12px; font-weight:bold; cursor:pointer; flex-shrink:0;">
         ✨ Generate Now
       </button>
-      <span id="ai-status" style="font-size:11px; color:#999; font-weight:normal;">waiting for first insight…</span>
+      <!-- LLM selector -->
+      <select id="ai-provider-select" onchange="onProviderChange()"
+              style="padding:4px 8px; border:1px solid #c5cae9; border-radius:8px; font-size:12px;
+                     background:#f8f9ff; color:#3949ab; cursor:pointer; flex-shrink:0;">
+        <option value="auto">Auto</option>
+        <option value="groq">Groq</option>
+        <option value="hf">HuggingFace</option>
+        <option value="ollama">Ollama</option>
+      </select>
+      <select id="ai-model-select" onchange="onModelChange()"
+              style="padding:4px 8px; border:1px solid #c5cae9; border-radius:8px; font-size:12px;
+                     background:#f8f9ff; color:#3949ab; cursor:pointer; flex-shrink:0; max-width:220px;">
+        <option value="">— model —</option>
+      </select>
+      <span id="ai-llm-badge" style="font-size:10px; color:#7986cb; background:#e8eaf6; padding:2px 8px;
+                                      border-radius:10px; white-space:nowrap; flex-shrink:0;"></span>
+      <span id="ai-status" style="font-size:11px; color:#999; font-weight:normal; margin-left:auto;">waiting for first insight…</span>
     </h2>
     <div id="ai-insights-list" style="max-height:220px; overflow-y:auto;">
       <div class="insight-card" style="color:#bbb; border-left-color:#ddd; background:#fafafa;" id="ai-placeholder">
@@ -433,6 +449,80 @@
     // Selected order state
     let selectedOrder = null;
 
+    // ── LLM selector ────────────────────────────────────────────────────────────
+    const LLM_MODELS = { auto: [], groq: [], hf: [], ollama: [] };
+
+    async function loadAIConfig() {
+      try {
+        const r = await fetch("/ai/config");
+        const cfg = await r.json();
+        // Populate model lists from server
+        for (const [p, info] of Object.entries(cfg.providers || {})) {
+          if (info.models && info.models.length) LLM_MODELS[p] = info.models;
+        }
+        // Restore active selection
+        const prov = cfg.active_provider || "auto";
+        document.getElementById("ai-provider-select").value = prov;
+        populateModelDropdown(prov, cfg.active_model);
+        updateLLMBadge(prov, cfg.active_model);
+      } catch(e) { console.warn("Could not load AI config:", e); }
+    }
+
+    function populateModelDropdown(provider, selectedModel) {
+      const sel = document.getElementById("ai-model-select");
+      const models = LLM_MODELS[provider] || [];
+      sel.innerHTML = "";
+      if (provider === "auto" || models.length === 0) {
+        sel.style.display = "none";
+        return;
+      }
+      sel.style.display = "";
+      for (const m of models) {
+        const opt = document.createElement("option");
+        opt.value = m;
+        opt.textContent = m.split("/").pop(); // show only model name, not org prefix
+        if (m === selectedModel) opt.selected = true;
+        sel.appendChild(opt);
+      }
+      if (!selectedModel) sel.selectedIndex = 0;
+    }
+
+    function updateLLMBadge(provider, model) {
+      const badge = document.getElementById("ai-llm-badge");
+      if (provider === "auto") {
+        badge.textContent = "auto";
+      } else {
+        const name = model ? model.split("/").pop() : "default";
+        badge.textContent = `${provider} / ${name}`;
+      }
+    }
+
+    async function sendLLMSelection(provider, model) {
+      try {
+        await fetch("/ai/select", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ provider, model: model || null }),
+        });
+      } catch(e) { console.warn("Could not update LLM selection:", e); }
+    }
+
+    function onProviderChange() {
+      const provider = document.getElementById("ai-provider-select").value;
+      populateModelDropdown(provider, null);
+      const model = LLM_MODELS[provider]?.[0] || null;
+      updateLLMBadge(provider, model);
+      sendLLMSelection(provider, model);
+    }
+
+    function onModelChange() {
+      const provider = document.getElementById("ai-provider-select").value;
+      const model    = document.getElementById("ai-model-select").value || null;
+      updateLLMBadge(provider, model);
+      sendLLMSelection(provider, model);
+    }
+    // ────────────────────────────────────────────────────────────────────────────
+
     async function triggerAIInsight() {
       const btn    = document.getElementById("ai-generate-btn");
       const status = document.getElementById("ai-status");
@@ -472,7 +562,10 @@
       div.className = "insight-card insight-new";
       if (isErr) div.style.cssText = "border-left-color:#e53935; background:#fff5f5;";
       const t = new Date(insight.timestamp * 1000).toLocaleTimeString();
-      div.innerHTML = `<div class="insight-time">${t}</div><div>${insight.text}</div>`;
+      const srcBadge = insight.source && insight.source !== "error" && insight.source !== "config"
+        ? `<span style="font-size:10px; background:#e8eaf6; color:#5c6bc0; padding:1px 6px; border-radius:8px; margin-left:6px;">${insight.source}</span>`
+        : "";
+      div.innerHTML = `<div class="insight-time">${t}${srcBadge}</div><div>${insight.text}</div>`;
       list.prepend(div);
       while (list.children.length > 10) list.removeChild(list.lastChild);
     }
@@ -1128,6 +1221,15 @@
         insights.forEach(addInsight);
       });
 
+      eventSource.addEventListener("llm_config", (e) => {
+        const cfg = JSON.parse(e.data);
+        const prov = cfg.provider || "auto";
+        const model = cfg.model || null;
+        document.getElementById("ai-provider-select").value = prov;
+        populateModelDropdown(prov, model);
+        updateLLMBadge(prov, model);
+      });
+
       eventSource.addEventListener("ai_insight", (e) => {
         const insight = JSON.parse(e.data);
         addInsight(insight);
@@ -1512,6 +1614,7 @@
     async function init() {
       await fetchData();
       connectSSE();
+      loadAIConfig();
 
       // Refresh order book panel every 3 seconds
       setInterval(() => {