Update backend.py

backend.py

@@ -1,17 +1,22 @@
 import os
+import json
 import pickle
+import re
 import tempfile
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 from dotenv import load_dotenv
 from faster_whisper import WhisperModel
 import anthropic
+from supabase import create_client
 
 load_dotenv()
 
 app = Flask(__name__)
 CORS(app)
 
+supabase = create_client(os.environ["SUPABASE_URL"], os.environ["SUPABASE_SERVICE_KEY"])
+
 print("Loading Whisper model (base)…")
 whisper_model = WhisperModel("base", device="cpu", compute_type="int8")
 print("Whisper ready.")
@@ -22,23 +27,6 @@ SYSTEM_PROMPT = """You are a concise diagnostic assistant for HP Metal Jet S100
 You receive real-time sensor data and answer operator questions in 1-3 short sentences.
 Be direct and technical. Always respond in English."""
 
-# ── Q-table for RL maintenance recommendations ────────────────────────────────
-_QTABLE: dict | None = None
-_QTABLE_PATH = os.path.join(os.path.dirname(__file__), "q_table.pkl")
-
-def _load_qtable() -> None:
-    global _QTABLE
-    try:
-        with open(_QTABLE_PATH, "rb") as f:
-            _QTABLE = pickle.load(f)
-        n_states = len(_QTABLE["Q"])
-        print(f"Q-table loaded ({n_states} visited states).")
-    except FileNotFoundError:
-        print("q_table.pkl not found — run phase2.py to train and save the Q-table.")
-        _QTABLE = None
-
-_load_qtable()
-
 
 @app.route("/api/transcribe", methods=["POST"])
 def transcribe():
@@ -59,89 +47,186 @@ def transcribe():
     finally:
         os.unlink(tmp_path)
 
+#END STUFF
+
+_SQL_SYSTEM = """You are a read-only PostgreSQL query generator for a fleet of HP Metal Jet S100 industrial 3D metal printers.
+Your only job is to output a single valid SQL SELECT statement that fetches exactly the data needed to answer the operator's question.
+
+DATABASE SCHEMA
+===============
+printers(
+  id           CHAR(20) PRIMARY KEY,
+  last_repair  TIMESTAMP
+)
+
+snapshots(
+  id                  CHAR(20) REFERENCES printers(id),  -- printer identifier
+  time_step_id        INT,                                -- monotonically increasing step counter
+  recoater_blade      FLOAT,   -- Recoating System   (0.0 = failed, 1.0 = perfect)
+  nozzle_plate        FLOAT,   -- Printhead Array
+  heating_elements    FLOAT,   -- Thermal Control
+  temperature_sensors FLOAT,   -- Thermal Control
+  insulation_panels   FLOAT,   -- Thermal Control
+  firing_resistors    FLOAT,   -- Printhead Array
+  cleaning_interface  FLOAT,   -- Printhead Array
+  recoater_motor      FLOAT,   -- Recoating System
+  linear_rail         FLOAT,   -- Recoating System
+  PRIMARY KEY (id, time_step_id)
+)
+
+conditions(
+  id                         CHAR(20) REFERENCES printers(id),
+  timestamp                  TIMESTAMP,
+  ambient_temperature_c      FLOAT,   -- degrees Celsius
+  build_chamber_temp_c       FLOAT,   -- degrees Celsius
+  ambient_humidity_pct       FLOAT,   -- percentage 0-100
+  powder_contamination_level FLOAT,   -- fraction 0-1
+  build_volume_cm3           FLOAT,   -- cm3
+  recoating_speed_mm_s       FLOAT,   -- mm/s
+  maintenance_level          FLOAT,   -- fraction 0-1, higher = better maintained
+  PRIMARY KEY (id, timestamp)
+)
+
+SUBSYSTEM GROUPINGS
+===================
+Thermal Control  : heating_elements, temperature_sensors, insulation_panels
+Printhead Array  : nozzle_plate, firing_resistors, cleaning_interface
+Recoating System : recoater_blade, recoater_motor, linear_rail
+
+HEALTH THRESHOLDS (all snapshot columns use the same scale)
+===========================================================
+>= 0.60 = healthy
+0.30 to 0.59 = warning
+< 0.30 = critical
+
+QUERY RULES
+===========
+1. Output ONLY the raw SQL — no markdown fences, no explanations, no semicolons.
+2. Always filter snapshots and conditions by id = '<printer_id>' unless the question explicitly asks for fleet-wide comparison.
+3. Current state  → SELECT all 9 health columns FROM snapshots WHERE id = '<printer_id>' ORDER BY time_step_id DESC LIMIT 1
+4. Trend / rate   → fetch the last N rows ORDER BY time_step_id ASC (use 50-100 rows for rate, 200+ for long-term trend).
+5. Anomaly        → compute AVG and STDDEV per component over a window, compare to latest value.
+6. Fleet queries  → omit the id filter, GROUP BY id, rank by computed health score.
+7. Maintenance    → join printers on id to access last_repair; join conditions on id for environmental context.
+8. Never use INSERT, UPDATE, DELETE, DROP, CREATE, TRUNCATE, or any DDL/DML.
+9. Default LIMIT 100; for full history queries up to LIMIT 500.
+10. When unsure which columns are relevant, select all 9 health columns — the answering model will filter.
+11. Use readable aliases: recoater_blade AS "Recoater Blade", etc."""
+
+_ANSWER_SYSTEM = """You are the digital co-pilot for HP Metal Jet S100 industrial 3D metal printers.
+You receive raw data fetched from a live sensor database and answer operator questions accurately and directly.
+
+TONE AND LENGTH
+===============
+- Floor operators need fast, actionable answers. Be direct and technical.
+- Simple state questions: 1-2 sentences.
+- Trend, anomaly, or multi-component questions: up to a short paragraph.
+- Never pad with filler phrases like "Based on the data provided..." — start with the answer.
+- Always respond in English.
+
+SEVERITY TAG (mandatory — always open your response with one)
+=============================================================
+[CRITICAL] — any component below 0.30, imminent failure predicted, or immediate action required
+[WARNING]  — any component between 0.30 and 0.59, accelerating degradation, or anomaly detected
+[INFO]     — all components healthy, routine query, or informational answer
+
+COMPONENT AND SUBSYSTEM REFERENCE
+==================================
+Thermal Control  : heating_elements, temperature_sensors, insulation_panels
+Printhead Array  : nozzle_plate, firing_resistors, cleaning_interface
+Recoating System : recoater_blade, recoater_motor, linear_rail
+
+Health scale: 0.0 = completely failed, 1.0 = perfect condition
+Thresholds  : >= 0.60 healthy, 0.30-0.59 warning, < 0.30 critical
+
+GROUNDING RULES (non-negotiable)
+=================================
+1. Answer only from the data rows provided. Never use training knowledge to fill gaps.
+2. Cite the specific value and time_step_id or timestamp for every number you state.
+3. If the data is empty or NULL, say explicitly: "No data available for [component] — cannot answer."
+4. Never extrapolate predictions beyond the available data window.
+5. If the question is outside the scope of the telemetry, say so clearly.
+
+RESPONSE PATTERNS BY QUESTION TYPE
+====================================
+Current state   → state the health value(s), their severity, and what it means operationally.
+Trend           → state direction (improving/degrading), magnitude (e.g. dropped 0.12 over 50 steps), and whether the rate is accelerating.
+Anomaly         → name the component, the step where the drop occurred, the before/after values, and whether it is isolated or correlated with others.
+Prediction      → state how many steps remain at current rate before crossing 0.30; do not guess beyond the data window.
+Root cause      → trace the sequence: which component moved first, which followed, and whether conditions (temperature, contamination) correlate.
+Fleet           → rank printers by overall health score; name the worst component across the fleet.
+Action/priority → rank by (lowest health + fastest degradation rate); name the single most urgent repair first.
+Maintenance     → state the last_repair timestamp and how many steps have elapsed since then.
+Aggregation     → provide the exact computed values (avg, min, max, stddev) with the time window they cover.
+No data         → "No data available for [X]. Check that the printer ID is correct and that snapshots exist for this time range."
+"""
+
+
+def _extract_sql(text: str) -> str:
+    text = text.strip()
+    # strip markdown code fences if the model adds them anyway
+    text = re.sub(r"^```[a-z]*\n?", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\n?```$", "", text)
+    return text.strip().rstrip(";")
+
 
 @app.route("/api/chat", methods=["POST"])
 def chat():
-    data = request.json
-    query = data.get("query", "")
-    ctx = data.get("context", {})
-
-    printer_ctx = (
-        f"Printer: {ctx.get('name')} (ID: {ctx.get('id')}, location: {ctx.get('location')})\n"
-        f"Overall health: {ctx.get('health')}%  |  Uptime 30d: {ctx.get('uptime')}%  |  Jobs since service: {ctx.get('jobs')}\n"
-        f"Components:\n"
+    data = request.json or {}
+    prompt = data.get("prompt", "").strip()
+    printer_id = data.get("printer_id", "")
+
+    if not prompt:
+        return jsonify({"error": "prompt is required"}), 400
+
+    # ── Step 1: ask LLM to generate a SQL query for the needed data ──────────
+    sql_resp = claude.messages.create(
+        model="claude-haiku-4-5-20251001",
+        max_tokens=400,
+        system=_SQL_SYSTEM,
+        messages=[{
+            "role": "user",
+            "content": (
+                f"Database schema:\n{_SCHEMA_SUMMARY}\n\n"
+                f"printer_id: {printer_id}\n"
+                f"User question: {prompt}"
+            ),
+        }],
     )
-    for c in ctx.get("components", []):
-        printer_ctx += f"  - {c['name']} ({c['subsystem']}): health {c['health']}%, trend 8w {c['trend8']:+}pts, predicted failure in {c['predictDays']}d\n"
+    sql = _extract_sql(sql_resp.content[0].text)
+    print(f"\n[SQL] {sql}\n")
 
-    message = claude.messages.create(
+    # ── Step 2: run the query against Supabase ───────────────────────────────
+    try:
+        rpc_result = supabase.rpc("run_readonly_query", {"query_text": sql}).execute()
+        db_data = rpc_result.data
+        if isinstance(db_data, str):
+            db_data = json.loads(db_data)
+        db_text = json.dumps(db_data, indent=2)
+    except Exception as exc:
+        print(f"[DB ERROR] {exc}")
+        db_text = f"Query failed: {exc}"
+
+    print(f"[DB RESULT] {db_text[:500]}\n")
+
+    # ── Step 3: ask LLM to answer using the retrieved data ───────────────────
+    answer_resp = claude.messages.create(
         model="claude-haiku-4-5-20251001",
-        max_tokens=250,
-        system=SYSTEM_PROMPT,
-        messages=[
-            {"role": "user", "content": f"{printer_ctx}\nOperator question: {query}"}
-        ],
+        max_tokens=300,
+        system=_ANSWER_SYSTEM,
+        messages=[{
+            "role": "user",
+            "content": (
+                f"Data fetched from database:\n{db_text}\n\n"
+                f"Operator question: {prompt}"
+            ),
+        }],
     )
 
-    answer = message.content[0].text
-    print(f"\n[CLAUDE] Q: {query}\nA: {answer}\n")
+    answer = answer_resp.content[0].text
+    print(f"[CLAUDE ANSWER] {answer}\n")
     return jsonify({"text": answer})
 
 
-@app.route("/api/recommend", methods=["POST"])
-def recommend():
-    """
-    RL maintenance recommendation.
-
-    Request body: { "health": [h0, h1, ..., h8] }
-        health values are floats in [0, 1], one per component in OBS_COMPS order:
-        recoater_blade, nozzle_plate, heating_elements, temperature_sensors,
-        insulation_panels, firing_resistors, cleaning_interface, recoater_motor, linear_rail
-
-    Response: {
-        "action": int,          // 0 = no-op, 1-9 = maintain component
-        "component": str|null,  // backend component key, null when action=0
-        "reason": str
-    }
-    """
-    if _QTABLE is None:
-        # Try reloading in case phase2.py has been run since startup
-        _load_qtable()
-        if _QTABLE is None:
-            return jsonify({
-                "action": 0,
-                "component": None,
-                "reason": "Q-table not available — run phase2.py first",
-            }), 200
-
-    data = request.json or {}
-    health = data.get("health", [])
-    obs_comps = _QTABLE["OBS_COMPS"]
-
-    if len(health) != len(obs_comps):
-        return jsonify({
-            "error": f"expected {len(obs_comps)} health values, got {len(health)}"
-        }), 400
-
-    N_BINS = _QTABLE["N_BINS"]
-    state = tuple(min(N_BINS - 1, int(h * N_BINS)) for h in health)
-
-    Q = _QTABLE["Q"]
-    n_actions = _QTABLE["n_actions"]
-    q_vals = Q.get(state, [0.0] * n_actions)
-    action = int(q_vals.index(max(q_vals)))
-
-    if action == 0:
-        return jsonify({"action": 0, "component": None, "reason": "Q-table: no maintenance needed"})
-
-    comp_name, _attr, recovery = _QTABLE["ACTIONS"][action]
-    return jsonify({
-        "action":    action,
-        "component": comp_name,
-        "recovery":  recovery,
-        "reason":    f"Q-table: state={state} → action={action}",
-    })
-
-
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=False)