Add runtime NN model switching: LLM, NN1 (Adilbai), NN2 (RayMelius)

Support dual NN model slots in ch_rl_trader with lazy loading per slot.
Six strategies: hybrid (USR01-04 LLM, USR05-07 NN1, USR08-10 NN2),
hybrid-nn1, hybrid-nn2, nn1, nn2, llm. Right-click context menu and
badges updated for NN1/NN2 distinction.

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

clearing_house/app.py

@@ -111,17 +111,7 @@ def _build_leaderboard(bbos: dict) -> list[dict]:
         row["total_value"] = round(row["capital"] + holdings_value, 2)
         row["pnl"] = round(row["total_value"] - db.CH_STARTING_CAPITAL, 2)
         row["is_human"] = ai_trader.is_human_active(row["member_id"])
-        # Determine AI type for this member
-        strategy = ai_trader.get_strategy()
-        if row["is_human"]:
-            row["ai_type"] = "Human"
-        elif strategy == "rl":
-            row["ai_type"] = "NN"
-        elif strategy == "llm":
-            row["ai_type"] = "LLM"
-        else:  # hybrid
-            member_num = int(row["member_id"][-2:])
-            row["ai_type"] = "NN" if member_num <= 5 else "LLM"
+        row["ai_type"] = _member_ai_type(row["member_id"])
     # Sort by total_value descending
     rows.sort(key=lambda r: r["total_value"], reverse=True)
     for i, row in enumerate(rows):
@@ -412,12 +402,24 @@ def _member_ai_type(member_id: str) -> str:
     if ai_trader.is_human_active(member_id):
         return "Human"
     strategy = ai_trader.get_strategy()
-    if strategy == "rl":
-        return "NN"
+    if strategy in ("nn1", "nn2"):
+        return strategy.upper()
     if strategy == "llm":
         return "LLM"
     member_num = int(member_id[-2:])
-    return "NN" if member_num <= 5 else "LLM"
+    if strategy == "hybrid":
+        # USR01-04 LLM, USR05-07 NN1, USR08-10 NN2
+        if member_num <= 4:
+            return "LLM"
+        elif member_num <= 7:
+            return "NN1"
+        else:
+            return "NN2"
+    # hybrid-nn1 or hybrid-nn2
+    if strategy.startswith("hybrid-"):
+        nn_slot = strategy.split("-", 1)[1].upper()
+        return nn_slot if member_num <= 5 else "LLM"
+    return "LLM"
 
 
 @app.route("/ch/api/market")
@@ -427,11 +429,17 @@ def api_market():
 
 @app.route("/ch/api/config")
 def api_config():
-    return jsonify({
+    result = {
         "strategy": ai_trader.get_strategy(),
         "obligation": db.CH_DAILY_OBLIGATION,
         "ai_interval": int(os.getenv("CH_AI_INTERVAL", "45")),
-    })
+    }
+    try:
+        from ch_rl_trader import get_model_info
+        result["nn_models"] = get_model_info()
+    except Exception:
+        pass
+    return jsonify(result)
 
 
 @app.route("/ch/api/strategy", methods=["POST"])

clearing_house/ch_ai_trader.py

@@ -7,7 +7,14 @@ Three background threads:
      for each unoccupied member using the configured strategy.
   3. _control_listener_thread – listens for session start/stop/suspend/resume.
 
-Strategy is selected via CH_AI_STRATEGY env var: "llm", "rl", or "hybrid".
+Strategy is selected via CH_AI_STRATEGY env var:
+  "hybrid"     – USR01-04 LLM, USR05-07 NN1, USR08-10 NN2 (default)
+  "hybrid-nn1" – USR01-05 NN1, USR06-10 LLM
+  "hybrid-nn2" – USR01-05 NN2, USR06-10 LLM
+  "llm"        – all members use LLM
+  "nn1"        – all members use NN1 (Adilbai/stock-trading-rl-agent)
+  "nn2"        – all members use NN2 (RayMelius/stockex-nn-agent)
+  Legacy alias: "rl" → "nn1"
 
 Call start() once from app.py after init_db().
 Call set_human_active(member_id) / set_human_inactive(member_id) on login/logout.
@@ -41,7 +48,11 @@ except ImportError:
 
 # ── Config ─────────────────────────────────────────────────────────────────────
 CH_AI_INTERVAL = int(os.getenv("CH_AI_INTERVAL", "45"))   # seconds between AI cycles
-CH_AI_STRATEGY = os.getenv("CH_AI_STRATEGY", "hybrid")     # "llm", "rl", or "hybrid"
+# Normalize legacy strategy names on startup
+_raw_strategy = os.getenv("CH_AI_STRATEGY", "hybrid")
+_STRATEGY_ALIASES = {"rl": "nn1", "hybrid-nn1": "hybrid-nn1", "hybrid-nn2": "hybrid-nn2"}
+CH_AI_STRATEGY = _STRATEGY_ALIASES.get(_raw_strategy, _raw_strategy)
+VALID_STRATEGIES = {"llm", "nn1", "nn2", "hybrid", "hybrid-nn1", "hybrid-nn2"}
 CH_SOURCE      = "CLRH"
 
 OLLAMA_HOST  = os.getenv("OLLAMA_HOST", "")
@@ -91,12 +102,21 @@ def set_strategy(strategy: str) -> str:
     """Dynamically switch AI strategy. Returns the active strategy."""
     global CH_AI_STRATEGY
     strategy = strategy.lower().strip()
-    if strategy not in ("llm", "rl", "hybrid"):
+    # Support legacy aliases
+    strategy = _STRATEGY_ALIASES.get(strategy, strategy)
+    if strategy not in VALID_STRATEGIES:
         return CH_AI_STRATEGY
-    if strategy in ("rl", "hybrid") and not _rl_available:
+    if strategy != "llm" and not _rl_available:
         print(f"[CH-AI] Cannot switch to {strategy}: RL deps not installed")
         return CH_AI_STRATEGY
     CH_AI_STRATEGY = strategy
+    # Tell RL trader which model slot to use
+    if _rl_available and strategy in ("nn1", "nn2"):
+        rl_trader.set_active_model(strategy)
+    elif _rl_available and strategy.startswith("hybrid-"):
+        nn_slot = strategy.split("-", 1)[1]
+        rl_trader.set_active_model(nn_slot)
+    # "hybrid" uses both nn1 and nn2, no single active model to set
     print(f"[CH-AI] Strategy switched to: {strategy}")
     return CH_AI_STRATEGY
 
@@ -109,9 +129,9 @@ def start() -> None:
     threading.Thread(target=_simulation_thread,     daemon=True, name="ch-ai-sim").start()
     threading.Thread(target=_control_listener_thread, daemon=True, name="ch-control").start()
     strategy = CH_AI_STRATEGY
-    if strategy in ("rl", "hybrid") and not _rl_available:
+    if strategy != "llm" and not _rl_available:
         strategy = "llm"
-        print("[CH-AI] WARNING: RL requested but deps missing, falling back to LLM")
+        print("[CH-AI] WARNING: NN requested but deps missing, falling back to LLM")
     print(f"[CH-AI] Background threads started (strategy={strategy})")
 
 
@@ -258,25 +278,38 @@ def _decide_order(member_id, capital, holdings, daily_trades, bbos, obligation_r
     """Dispatch to the configured strategy."""
     strategy = CH_AI_STRATEGY
 
-    # Hybrid: split members between RL and LLM
+    # Hybrid modes: split members between strategies
+    member_num = int(member_id[-2:])
     if strategy == "hybrid" and _rl_available:
-        member_num = int(member_id[-2:])
-        strategy = "rl" if member_num <= 5 else "llm"
-
-    if strategy == "rl" and _rl_available:
+        # Default hybrid: USR01-04 LLM, USR05-07 NN1, USR08-10 NN2
+        if member_num <= 4:
+            strategy = "llm"
+        elif member_num <= 7:
+            strategy = "nn1"
+        else:
+            strategy = "nn2"
+    elif strategy.startswith("hybrid-") and _rl_available:
+        nn_slot = strategy.split("-", 1)[1]  # "nn1" or "nn2"
+        if member_num <= 5:
+            strategy = nn_slot
+        else:
+            strategy = "llm"
+
+    if strategy in ("nn1", "nn2") and _rl_available:
         try:
             order = rl_trader.decide_order_rl(
                 member_id, capital, holdings, bbos, obligation_remaining,
+                model_slot=strategy,
             )
             if order and _validate_order(order, capital, holdings, bbos):
                 try:
-                    db.record_ai_decision(member_id, f"RL: {order}", order, source="rl")
+                    db.record_ai_decision(member_id, f"RL({strategy}): {order}", order, source=strategy)
                 except Exception:
                     pass
                 return order
         except Exception as e:
-            print(f"[CH-AI] RL strategy error for {member_id}: {e}")
-        # Fall through to LLM on RL failure
+            print(f"[CH-AI] {strategy} strategy error for {member_id}: {e}")
+        # Fall through to LLM on NN failure
         return _decide_order_llm(
             member_id, capital, holdings, daily_trades, bbos, obligation_remaining,
         )

clearing_house/ch_rl_trader.py

@@ -1,4 +1,8 @@
-"""RL-based trading strategy using Adilbai/stock-trading-rl-agent (PPO).
+"""RL-based trading strategy using PPO models from HuggingFace Hub.
+
+Supports two model slots:
+  - nn1: Adilbai/stock-trading-rl-agent
+  - nn2: RayMelius/stockex-nn-agent
 
 Provides decide_order_rl() with the same return type as _decide_order_llm()
 so it can be used as a drop-in alternative in ch_ai_trader.py.
@@ -15,17 +19,21 @@ from typing import Optional
 import numpy as np
 
 # ── Config ────────────────────────────────────────────────────────────────────
-RL_MODEL_REPO = os.getenv("CH_RL_MODEL_REPO", "Adilbai/stock-trading-rl-agent")
+RL_MODEL_REPOS = {
+    "nn1": os.getenv("CH_RL_MODEL_REPO_NN1", os.getenv("CH_RL_MODEL_REPO", "Adilbai/stock-trading-rl-agent")),
+    "nn2": os.getenv("CH_RL_MODEL_REPO_NN2", "RayMelius/stockex-nn-agent"),
+}
 RL_MODEL_CACHE = os.getenv("CH_RL_MODEL_CACHE", "/app/data/rl_model")
 RL_BAR_INTERVAL = int(os.getenv("CH_RL_BAR_INTERVAL", "60"))  # seconds per bar
 RL_MIN_BARS = int(os.getenv("CH_RL_MIN_BARS", "30"))          # min bars before RL kicks in
 RL_LOOKBACK = 60
 
 # ── Shared state ──────────────────────────────────────────────────────────────
-_model = None
-_scaler = None
+# Per-model-slot: {"nn1": (model, scaler), "nn2": (model, scaler)}
+_models: dict[str, tuple] = {}
+_load_attempted: dict[str, bool] = {}
 _model_lock = threading.Lock()
-_load_attempted = False
+_active_model: str = "nn1"  # which model slot to use by default
 
 # Per-symbol rolling price bars: {symbol: deque of {open, high, low, close, volume}}
 _price_bars: dict[str, deque] = {}
@@ -36,45 +44,81 @@ _current_bar: dict[str, dict] = {}
 
 # ── Model loading ─────────────────────────────────────────────────────────────
 
-def _load_model():
-    """Download and load the PPO model + scaler from HuggingFace Hub."""
-    global _model, _scaler, _load_attempted
+def _load_model(slot: str = "nn1") -> bool:
+    """Download and load a PPO model + scaler from HuggingFace Hub."""
     with _model_lock:
-        if _load_attempted:
-            return _model is not None
-        _load_attempted = True
+        if _load_attempted.get(slot):
+            return slot in _models
+        _load_attempted[slot] = True
+
+    repo = RL_MODEL_REPOS.get(slot)
+    if not repo:
+        print(f"[CH-RL] No repo configured for slot '{slot}'")
+        return False
 
     try:
         from huggingface_hub import hf_hub_download
         from stable_baselines3 import PPO
 
-        os.makedirs(RL_MODEL_CACHE, exist_ok=True)
-        print(f"[CH-RL] Downloading model from {RL_MODEL_REPO}...")
+        cache_dir = os.path.join(RL_MODEL_CACHE, slot)
+        os.makedirs(cache_dir, exist_ok=True)
+        print(f"[CH-RL] Downloading {slot} model from {repo}...")
 
         model_path = hf_hub_download(
-            repo_id=RL_MODEL_REPO, filename="final_model.zip",
-            cache_dir=RL_MODEL_CACHE,
+            repo_id=repo, filename="final_model.zip",
+            cache_dir=cache_dir,
         )
         scaler_path = hf_hub_download(
-            repo_id=RL_MODEL_REPO, filename="scaler.pkl",
-            cache_dir=RL_MODEL_CACHE,
+            repo_id=repo, filename="scaler.pkl",
+            cache_dir=cache_dir,
         )
 
+        model = PPO.load(model_path)
+        with open(scaler_path, "rb") as f:
+            scaler = pickle.load(f)
+
         with _model_lock:
-            _model = PPO.load(model_path)
-            with open(scaler_path, "rb") as f:
-                _scaler = pickle.load(f)
+            _models[slot] = (model, scaler)
 
-        print("[CH-RL] Model loaded successfully")
+        print(f"[CH-RL] Model '{slot}' loaded successfully from {repo}")
         return True
     except Exception as e:
-        print(f"[CH-RL] Failed to load model: {e}")
+        print(f"[CH-RL] Failed to load model '{slot}' from {repo}: {e}")
         return False
 
 
-def is_available() -> bool:
-    """Check if RL model is loaded and ready."""
-    return _model is not None
+def is_available(slot: str | None = None) -> bool:
+    """Check if an RL model is loaded and ready."""
+    if slot:
+        return slot in _models or not _load_attempted.get(slot, False)
+    # At least one model available or not yet attempted
+    return bool(_models) or not all(_load_attempted.get(s, False) for s in RL_MODEL_REPOS)
+
+
+def get_active_model() -> str:
+    """Return the currently active model slot name."""
+    return _active_model
+
+
+def set_active_model(slot: str) -> str:
+    """Switch the active NN model. Returns the active slot name."""
+    global _active_model
+    if slot in RL_MODEL_REPOS:
+        _active_model = slot
+        print(f"[CH-RL] Active model switched to: {slot} ({RL_MODEL_REPOS[slot]})")
+    return _active_model
+
+
+def get_model_info() -> dict:
+    """Return info about available model slots."""
+    return {
+        slot: {
+            "repo": repo,
+            "loaded": slot in _models,
+            "active": slot == _active_model,
+        }
+        for slot, repo in RL_MODEL_REPOS.items()
+    }
 
 
 # ── Price history ─────────────────────────────────────────────────────────────
@@ -283,6 +327,7 @@ def _build_observation(
     capital: float,
     holdings: list,
     bbos: dict,
+    slot: str | None = None,
 ) -> Optional[np.ndarray]:
     """Build the 3008-dim observation vector for one symbol."""
     with _bars_lock:
@@ -299,10 +344,15 @@ def _build_observation(
 
     indicators = _compute_indicators(bars)  # (60, 50)
 
-    # Scale using the loaded scaler
-    if _scaler is not None:
+    # Scale using the scaler for the requested model slot
+    scaler = None
+    use_slot = slot or _active_model
+    with _model_lock:
+        if use_slot in _models:
+            scaler = _models[use_slot][1]
+    if scaler is not None:
         try:
-            indicators = _scaler.transform(indicators)
+            indicators = scaler.transform(indicators)
         except Exception:
             # Shape mismatch — normalize manually
             mean = indicators.mean(axis=0)
@@ -348,11 +398,19 @@ def decide_order_rl(
     holdings: list,
     bbos: dict,
     obligation_remaining: int,
+    model_slot: str | None = None,
 ) -> Optional[dict]:
     """Use the RL model to decide a trade. Returns order dict or None."""
-    if not _model:
-        if not _load_model():
+    slot = model_slot or _active_model
+    with _model_lock:
+        model_loaded = slot in _models
+    if not model_loaded:
+        if not _load_model(slot):
+            return None
+    with _model_lock:
+        if slot not in _models:
             return None
+        model, _slot_scaler = _models[slot]
 
     # Seed price history from BBOs for symbols we haven't seen
     for sym, bbo in bbos.items():
@@ -370,12 +428,12 @@ def decide_order_rl(
     candidates = []
 
     for sym, bbo in bbos.items():
-        obs = _build_observation(sym, capital, holdings, bbos)
+        obs = _build_observation(sym, capital, holdings, bbos, slot=slot)
         if obs is None:
             continue
 
         try:
-            action, _ = _model.predict(obs, deterministic=False)
+            action, _ = model.predict(obs, deterministic=False)
             action_type = int(round(float(action[0])))
             position_size = float(np.clip(action[1], 0.05, 0.5))
 

clearing_house/templates/dashboard.html

@@ -51,8 +51,10 @@
         <td>
           {% if row.is_human %}
             <span class="badge-human">Human</span>
-          {% elif row.ai_type == 'NN' %}
-            <span class="badge-ai" style="background:#00695c;">NN</span>
+          {% elif row.ai_type == 'NN1' %}
+            <span class="badge-ai" style="background:#00695c;">NN1</span>
+          {% elif row.ai_type == 'NN2' %}
+            <span class="badge-ai" style="background:#00838f;">NN2</span>
           {% else %}
             <span class="badge-ai" style="background:#5c6bc0;">LLM</span>
           {% endif %}
@@ -82,7 +84,7 @@
 <p style="color:var(--muted); font-size:11px; margin-top:8px;">
   Daily obligation: each member must trade at least {{ obligation }} securities.
   Holdings value is calculated at current market mid-price.
-  Click a row for full member detail. Right-click table to switch AI strategy. Refreshes every 10 seconds.
+  Click a row for full member detail. Right-click table to switch AI model (LLM / NN1 / NN2). Refreshes every 10 seconds.
 </p>
 
 <!-- Member detail slide-out panel -->
@@ -121,9 +123,11 @@ async function refreshLeaderboard() {
         : `<span class="badge-bad">${row.total_securities}/{{ obligation }}</span>`;
       const typeBadge = row.is_human
         ? `<span class="badge-human">Human</span>`
-        : row.ai_type === 'NN'
-          ? `<span class="badge-ai" style="background:#00695c;">NN</span>`
-          : `<span class="badge-ai" style="background:#5c6bc0;">LLM</span>`;
+        : row.ai_type === 'NN1'
+          ? `<span class="badge-ai" style="background:#00695c;">NN1</span>`
+          : row.ai_type === 'NN2'
+            ? `<span class="badge-ai" style="background:#00838f;">NN2</span>`
+            : `<span class="badge-ai" style="background:#5c6bc0;">LLM</span>`;
       tbody.innerHTML += `
         <tr data-member="${row.member_id}" style="cursor:pointer">
           <td style="color:var(--muted)">${row.rank}</td>
@@ -183,9 +187,11 @@ async function openDetail(memberId) {
     const pnlSign = d.pnl >= 0 ? '+' : '';
     const typeBadge = d.is_human
       ? '<span class="badge-human">Human</span>'
-      : d.ai_type === 'NN'
-        ? '<span class="badge-ai" style="background:#00695c;">NN</span>'
-        : '<span class="badge-ai" style="background:#5c6bc0;">LLM</span>';
+      : d.ai_type === 'NN1'
+        ? '<span class="badge-ai" style="background:#00695c;">NN1</span>'
+        : d.ai_type === 'NN2'
+          ? '<span class="badge-ai" style="background:#00838f;">NN2</span>'
+          : '<span class="badge-ai" style="background:#5c6bc0;">LLM</span>';
     const oblStatus = d.daily.total_securities >= d.obligation
       ? `<span class="badge-ok">Met (${d.daily.total_securities}/${d.obligation})</span>`
       : `<span class="badge-bad">${d.daily.total_securities}/${d.obligation}</span>`;
@@ -273,13 +279,16 @@ async function openDetail(memberId) {
       html += `<h3 style="margin:20px 0 8px;">AI Reasoning (last ${d.ai_decisions.length})</h3>`;
       d.ai_decisions.forEach(dec => {
         const ts = new Date(dec.timestamp * 1000).toLocaleTimeString();
-        const srcBadge = dec.source === 'llm'
-          ? '<span style="background:#e8eaf6; color:#5c6bc0; padding:1px 6px; border-radius:8px; font-size:10px;">LLM</span>'
-          : dec.source === 'rl'
-            ? '<span style="background:#e0f2f1; color:#00695c; padding:1px 6px; border-radius:8px; font-size:10px;">NN</span>'
-            : dec.source === 'fallback'
-              ? '<span style="background:#fff3e0; color:#e65100; padding:1px 6px; border-radius:8px; font-size:10px;">Fallback</span>'
-              : `<span style="background:#ffebee; color:#c62828; padding:1px 6px; border-radius:8px; font-size:10px;">${dec.source}</span>`;
+        const srcColors = {
+          'llm': {bg:'#e8eaf6', fg:'#5c6bc0'},
+          'nn1': {bg:'#e0f2f1', fg:'#00695c'},
+          'nn2': {bg:'#e0f7fa', fg:'#00838f'},
+          'rl':  {bg:'#e0f2f1', fg:'#00695c'},
+          'fallback': {bg:'#fff3e0', fg:'#e65100'},
+        };
+        const sc = srcColors[dec.source] || {bg:'#ffebee', fg:'#c62828'};
+        const srcLabel = dec.source === 'rl' ? 'NN1' : dec.source.toUpperCase();
+        const srcBadge = `<span style="background:${sc.bg}; color:${sc.fg}; padding:1px 6px; border-radius:8px; font-size:10px;">${srcLabel}</span>`;
         const order = dec.parsed_order;
         const orderLine = order
           ? `<span class="${order.side === 'BUY' ? 'positive' : 'negative'}" style="font-weight:bold;">${order.side}</span> ${order.quantity} <strong>${order.symbol}</strong> @ €${fmt(order.price)}`
@@ -315,8 +324,12 @@ ctxMenu.style.cssText = `
 `;
 ctxMenu.innerHTML = `
   <div style="padding:6px 14px; color:var(--muted); font-size:11px; font-weight:bold;">AI Strategy</div>
-  <div class="ctx-item" data-strategy="hybrid" style="padding:8px 14px; cursor:pointer;">Hybrid (NN + LLM)</div>
-  <div class="ctx-item" data-strategy="rl" style="padding:8px 14px; cursor:pointer;">All NN (Neural Network)</div>
+  <div class="ctx-item" data-strategy="hybrid" style="padding:8px 14px; cursor:pointer;">Hybrid (LLM + NN1 + NN2)</div>
+  <div class="ctx-item" data-strategy="hybrid-nn1" style="padding:8px 14px; cursor:pointer;">Hybrid (NN1 + LLM)</div>
+  <div class="ctx-item" data-strategy="hybrid-nn2" style="padding:8px 14px; cursor:pointer;">Hybrid (NN2 + LLM)</div>
+  <div style="border-top:1px solid var(--border, #333); margin:4px 0;"></div>
+  <div class="ctx-item" data-strategy="nn1" style="padding:8px 14px; cursor:pointer;">All NN1</div>
+  <div class="ctx-item" data-strategy="nn2" style="padding:8px 14px; cursor:pointer;">All NN2</div>
   <div class="ctx-item" data-strategy="llm" style="padding:8px 14px; cursor:pointer;">All LLM</div>
 `;
 document.body.appendChild(ctxMenu);
@@ -341,6 +354,15 @@ document.getElementById('lb-table').addEventListener('contextmenu', (e) => {
 // Hide on click elsewhere
 document.addEventListener('click', () => ctxMenu.style.display = 'none');
 
+const STRATEGY_LABELS = {
+  'hybrid': 'Hybrid (LLM + NN1 + NN2)',
+  'hybrid-nn1': 'Hybrid (NN1 + LLM)',
+  'hybrid-nn2': 'Hybrid (NN2 + LLM)',
+  'nn1': 'All NN1',
+  'nn2': 'All NN2',
+  'llm': 'All LLM',
+};
+
 async function highlightCurrentStrategy() {
   try {
     const resp = await fetch('/ch/api/config');
@@ -349,9 +371,7 @@ async function highlightCurrentStrategy() {
       const isCurrent = item.dataset.strategy === cfg.strategy;
       item.style.fontWeight = isCurrent ? 'bold' : 'normal';
       item.style.color = isCurrent ? 'var(--accent, #42a5f5)' : 'var(--text, #ccc)';
-      // Reset text to base, then append checkmark
-      const base = item.dataset.strategy === 'hybrid' ? 'Hybrid (NN + LLM)'
-        : item.dataset.strategy === 'rl' ? 'All NN (Neural Network)' : 'All LLM';
+      const base = STRATEGY_LABELS[item.dataset.strategy] || item.dataset.strategy;
       item.textContent = isCurrent ? base + ' \u2713' : base;
     });
   } catch(e) {}

docker-compose.yml

@@ -204,6 +204,8 @@ services:
       - GROQ_MODEL=${GROQ_MODEL:-llama-3.1-8b-instant}
       - OLLAMA_HOST=${OLLAMA_HOST:-}
       - CH_AI_STRATEGY=${CH_AI_STRATEGY:-hybrid}
+      - CH_RL_MODEL_REPO_NN1=${CH_RL_MODEL_REPO_NN1:-Adilbai/stock-trading-rl-agent}
+      - CH_RL_MODEL_REPO_NN2=${CH_RL_MODEL_REPO_NN2:-RayMelius/stockex-nn-agent}
     extra_hosts:
       - "host.docker.internal:host-gateway"