Update main.py

main.py

@@ -1,21 +1,32 @@
 """
-main.py — Iris AI Service (v1.0 - April 2026)
+main.py — Iris AI Service (v1.1 - April 2026)
 
 AI layer for the Iris Support Portal (IrisPlus / Unified Spark Desk).
 Deployed as a HuggingFace Space monofile (Flask + Gemini + AssemblyAI + Firebase).
 
+CHANGELOG v1.1:
+  - Model: gemini-3.1-flash-lite-preview (multimodal reasoning)
+  - /api/kb/whatsapp-import: now accepts multipart ZIP upload
+    * Extracts _chat.txt + maps image files to <Media omitted> pointers
+    * Sliding-window chunking (~10k tokens / ~40k chars with overlap)
+    * Multimodal: sends images inline with their surrounding text chunk
+    * Strict JSON enforcement + pre-save validation
+    * JSON parse error recovery (regex extraction fallback)
+  - All other endpoints unchanged from v1.0
+
 FEATURES:
-  1. WhatsApp Export → Knowledge Base (intelligent Gemini extraction, additive only)
+  1. WhatsApp Export → Knowledge Base (ZIP multimodal, chunked, additive)
   2. Bulk KB Upload (CSV / Excel / PDF)
-  3. Natural Language + Voice Ticket Submission (AssemblyAI transcription → Gemini extraction)
-  4. System Tutorial Ingestion (video transcript → timestamped KB articles)
-  5. Agent NL/Voice Solution Writing (same pipeline, agent role)
-  6. Iris Chatbot (KB + tutorial source RAG, Firebase persistence)
+  3. Natural Language + Voice Ticket Submission
+  4. System Tutorial Ingestion (timestamped transcripts)
+  5. Agent NL/Voice Solution Writing
+  6. Iris Chatbot (KB RAG)
 
 ENV VARS:
   GOOGLE_API_KEY       — Gemini API key
   ASSEMBLYAI_API_KEY   — AssemblyAI API key
   FIREBASE             — JSON string of Firebase service account
+  GEMINI_MODEL         — Override model (default: gemini-3.1-flash-lite-preview)
   PORT                 — Server port (default 7860)
 """
 
@@ -27,8 +38,10 @@ import time
 import logging
 import base64
 import hashlib
+import zipfile
+import tempfile
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import requests
 from flask import Flask, request, jsonify
@@ -52,7 +65,8 @@ except Exception as e:
     logger.error("google-genai not installed: %s", e)
 
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
-GEMINI_MODEL   = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash-lite")
+# v1.1: upgraded to gemini-3.1-flash-lite-preview for multimodal reasoning
+GEMINI_MODEL   = os.environ.get("GEMINI_MODEL", "gemini-3.1-flash-lite-preview")
 
 _gemini_client = None
 if genai and GOOGLE_API_KEY:
@@ -99,7 +113,7 @@ def init_firestore() -> Optional[Any]:
 
 db = init_firestore()
 
-# ─── Optional file-parsing libs ───────────────────────────────────────────────
+# ─── Optional libs ────────────────────────────────────────────────────────────
 
 try:
     import pandas as pd
@@ -119,28 +133,98 @@ app = Flask(__name__)
 CORS(app)
 
 # ══════════════════════════════════════════════════════════════════════════════
-# HELPERS
+# SHARED HELPERS
 # ══════════════════════════════════════════════════════════════════════════════
 
+# Supported image extensions for multimodal WhatsApp ingestion
+SUPPORTED_IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
+
+# Approx chars per token (conservative for mixed Shona/English/emoji content)
+CHARS_PER_TOKEN = 4
+# Target ~10k tokens per chunk with ~1k token overlap
+CHUNK_CHARS    = 40_000
+OVERLAP_CHARS  =  4_000
+
+
 def _safe_json(text: str, fallback: Any) -> Any:
-    """Strip markdown fences and parse JSON safely."""
+    """
+    Multi-strategy JSON parser.
+    1. Direct parse after stripping markdown fences.
+    2. Regex extraction of first [...] or {...} block.
+    3. Return fallback.
+    """
+    if not text:
+        return fallback
+
+    # Strategy 1: strip fences
+    clean = text.strip()
+    for fence in ("```json", "```JSON", "```"):
+        if fence in clean:
+            parts = clean.split(fence)
+            # take the content between the first pair of fences
+            if len(parts) >= 3:
+                clean = parts[1].strip()
+            elif len(parts) == 2:
+                clean = parts[1].split("```")[0].strip()
+            break
+
     try:
-        clean = text.strip()
-        if "```json" in clean:
-            clean = clean.split("```json")[1].split("```")[0]
-        elif "```" in clean:
-            clean = clean.split("```")[1].split("```")[0]
         return json.loads(clean)
-    except Exception as e:
-        logger.error("JSON parse error: %s | text: %s", e, text[:200])
-        return fallback
+    except json.JSONDecodeError:
+        pass
+
+    # Strategy 2: regex — find outermost [...] array
+    arr_match = re.search(r'\[[\s\S]*\]', clean)
+    if arr_match:
+        try:
+            return json.loads(arr_match.group())
+        except json.JSONDecodeError:
+            pass
+
+    # Strategy 3: regex — find outermost {...} object
+    obj_match = re.search(r'\{[\s\S]*\}', clean)
+    if obj_match:
+        try:
+            return json.loads(obj_match.group())
+        except json.JSONDecodeError:
+            pass
+
+    logger.error("JSON parse exhausted all strategies. First 300 chars: %s", text[:300])
+    return fallback
+
+
+def _validate_articles(data: Any) -> List[Dict]:
+    """
+    Validate that extracted articles are a list of dicts with required fields.
+    Filters out malformed items rather than failing the whole batch.
+    """
+    if not isinstance(data, list):
+        logger.warning("Expected list from Gemini, got %s", type(data))
+        return []
+    valid = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        title   = str(item.get("title", "")).strip()
+        content = str(item.get("content", "")).strip()
+        if len(title) < 3 or len(content) < 10:
+            continue
+        valid.append({
+            "title":    title,
+            "content":  content,
+            "category": str(item.get("category", "General")).strip() or "General",
+            "tags":     item.get("tags", []) if isinstance(item.get("tags"), list) else [],
+        })
+    return valid
 
 
 def _gemini_text(prompt: str, json_mode: bool = False) -> str:
-    """Call Gemini and return raw text."""
+    """Call Gemini with text-only content."""
     if not _gemini_client:
         return ""
-    cfg = genai_types.GenerateContentConfig(response_mime_type="application/json") if json_mode else None
+    cfg = genai_types.GenerateContentConfig(
+        response_mime_type="application/json"
+    ) if json_mode else None
     try:
         resp = _gemini_client.models.generate_content(
             model=GEMINI_MODEL,
@@ -149,18 +233,35 @@ def _gemini_text(prompt: str, json_mode: bool = False) -> str:
         )
         return resp.text or ""
     except Exception as e:
-        logger.error("Gemini call error: %s", e)
+        logger.error("Gemini text call error: %s", e)
+        return ""
+
+
+def _gemini_multimodal(parts: list, json_mode: bool = False) -> str:
+    """Call Gemini with a mixed list of text strings and image Parts."""
+    if not _gemini_client:
+        return ""
+    cfg = genai_types.GenerateContentConfig(
+        response_mime_type="application/json"
+    ) if json_mode else None
+    try:
+        resp = _gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=parts,
+            config=cfg
+        )
+        return resp.text or ""
+    except Exception as e:
+        logger.error("Gemini multimodal call error: %s", e)
         return ""
 
 
 def _article_fingerprint(title: str, content: str) -> str:
-    """Stable hash to detect duplicate KB articles."""
     raw = f"{title.strip().lower()}::{content.strip().lower()[:300]}"
     return hashlib.sha256(raw.encode()).hexdigest()[:16]
 
 
 def _get_existing_fingerprints() -> set:
-    """Fetch all fingerprints already in Firestore KB."""
     if not db:
         return set()
     try:
@@ -172,22 +273,17 @@ def _get_existing_fingerprints() -> set:
 
 
 def _save_kb_articles(articles: List[Dict], source_label: str) -> Dict:
-    """Save articles to Firestore, skip duplicates. Returns stats."""
     if not db:
         return {"saved": 0, "skipped": 0, "error": "Firebase unavailable"}
-
     existing = _get_existing_fingerprints()
     saved, skipped = 0, 0
-
     for article in articles:
         title   = article.get("title", "Untitled")
         content = article.get("content", "")
         fp      = _article_fingerprint(title, content)
-
         if fp in existing:
             skipped += 1
             continue
-
         doc = {
             "title":       title,
             "content":     content,
@@ -197,79 +293,327 @@ def _save_kb_articles(articles: List[Dict], source_label: str) -> Dict:
             "fingerprint": fp,
             "created_at":  datetime.now(timezone.utc).isoformat(),
         }
-        # Carry timestamp crop info from tutorial ingestion if present
         if article.get("timestamp_start") is not None:
             doc["timestamp_start"] = article["timestamp_start"]
             doc["timestamp_end"]   = article.get("timestamp_end")
             doc["video_url"]       = article.get("video_url", "")
-
         db.collection("iris_kb_articles").add(doc)
         existing.add(fp)
         saved += 1
-
     return {"saved": saved, "skipped": skipped}
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-# FEATURE 1 — WhatsApp Export → Knowledge Base
+# WHATSAPP ZIP PROCESSOR
+# ══════════════════════════════════════════════════════════════════════════════
+
+# Regex to match WhatsApp timestamp lines
+# Handles both: DD/MM/YYYY, HH:MM - Sender: message
+# and:          DD/MM/YYYY, HH:MM am/pm - Sender: message
+WA_LINE_RE = re.compile(
+    r'^\d{1,2}/\d{1,2}/\d{4},\s+\d{1,2}:\d{2}(?:\s*[ap]m)?\s+-\s+',
+    re.IGNORECASE
+)
+
+# Matches <Media omitted> or [filename.jpg] style media pointers
+MEDIA_POINTER_RE = re.compile(
+    r'<Media omitted>|\[?([^\]]+\.(?:jpg|jpeg|png|webp|gif|mp4|opus|aac|m4a))\]?',
+    re.IGNORECASE
+)
+
+
+class WhatsAppZipProcessor:
+    """
+    Handles extraction and multimodal chunking of a WhatsApp .zip export.
+
+    A WhatsApp export zip typically contains:
+      _chat.txt          — the full conversation
+      IMG-YYYYMMDD-*.jpg — attached images
+      VID-*.mp4          — videos (we skip these, too large)
+      PTT-*.opus         — voice notes (skipped)
+    """
+
+    def __init__(self, zip_bytes: bytes):
+        self.zip_bytes   = zip_bytes
+        self.chat_text   = ""
+        self.media_map: Dict[str, bytes] = {}  # filename -> raw bytes
+
+    def extract(self) -> bool:
+        """Extract chat text and image files from ZIP. Returns True on success."""
+        try:
+            with zipfile.ZipFile(io.BytesIO(self.zip_bytes)) as zf:
+                names = zf.namelist()
+                logger.info("ZIP contains %d files: %s", len(names), names[:20])
+
+                # Find chat file — WhatsApp names it _chat.txt or WhatsApp Chat with *.txt
+                chat_file = None
+                for name in names:
+                    base = os.path.basename(name).lower()
+                    if base == "_chat.txt" or (base.endswith(".txt") and "chat" in base):
+                        chat_file = name
+                        break
+                if not chat_file:
+                    # Fallback: any .txt file
+                    txts = [n for n in names if n.lower().endswith(".txt")]
+                    if txts:
+                        chat_file = txts[0]
+
+                if not chat_file:
+                    logger.error("No chat .txt found in ZIP")
+                    return False
+
+                raw = zf.read(chat_file)
+                self.chat_text = raw.decode("utf-8", errors="replace")
+                logger.info("Chat text extracted: %d chars from %s", len(self.chat_text), chat_file)
+
+                # Extract images (skip videos and audio — too large / not useful for KB)
+                for name in names:
+                    ext = os.path.splitext(name.lower())[1]
+                    if ext in SUPPORTED_IMAGE_EXTS:
+                        try:
+                            self.media_map[os.path.basename(name)] = zf.read(name)
+                        except Exception as e:
+                            logger.warning("Could not read media file %s: %s", name, e)
+
+                logger.info("Media files extracted: %d images", len(self.media_map))
+                return True
+
+        except zipfile.BadZipFile as e:
+            logger.error("Bad ZIP file: %s", e)
+            return False
+        except Exception as e:
+            logger.error("ZIP extraction error: %s", e)
+            return False
+
+    def _resolve_media_in_line(self, line: str) -> Optional[bytes]:
+        """
+        Given a chat line, check if it references a media file we have.
+        Returns the image bytes if found, else None.
+        """
+        match = MEDIA_POINTER_RE.search(line)
+        if not match:
+            return None
+        filename = match.group(1)  # group 1 = explicit filename, None for <Media omitted>
+        if filename:
+            fname = os.path.basename(filename)
+            if fname in self.media_map:
+                return self.media_map[fname]
+        # <Media omitted> — we can't recover the file since it wasn't exported
+        return None
+
+    def build_chunks(self) -> List[Dict]:
+        """
+        Split chat text into overlapping chunks, each annotated with
+        the image bytes found within that chunk.
+
+        Returns list of:
+          { "text": str, "images": [bytes, ...], "line_range": (start, end) }
+        """
+        lines  = self.chat_text.splitlines()
+        chunks = []
+
+        i        = 0
+        total    = len(lines)
+        char_count = 0
+        chunk_lines: List[str] = []
+        chunk_images: List[bytes] = []
+
+        while i < total:
+            line = lines[i]
+            chunk_lines.append(line)
+            char_count += len(line) + 1  # +1 for newline
+
+            # Check if this line has an image we can include
+            img_bytes = self._resolve_media_in_line(line)
+            if img_bytes and len(chunk_images) < 5:  # cap images per chunk
+                chunk_images.append(img_bytes)
+
+            if char_count >= CHUNK_CHARS or i == total - 1:
+                chunks.append({
+                    "text":   "\n".join(chunk_lines),
+                    "images": chunk_images[:],
+                    "line_range": (i - len(chunk_lines) + 1, i)
+                })
+                logger.info(
+                    "Chunk %d: %d lines, %d chars, %d images",
+                    len(chunks), len(chunk_lines), char_count, len(chunk_images)
+                )
+                # Overlap: keep last OVERLAP_CHARS worth of lines for next chunk
+                overlap_text = 0
+                overlap_start = len(chunk_lines) - 1
+                while overlap_start > 0 and overlap_text < OVERLAP_CHARS:
+                    overlap_text += len(chunk_lines[overlap_start]) + 1
+                    overlap_start -= 1
+                chunk_lines  = chunk_lines[overlap_start:]
+                chunk_images = []
+                char_count   = sum(len(l) + 1 for l in chunk_lines)
+            i += 1
+
+        logger.info("Total chunks: %d", len(chunks))
+        return chunks
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# WHATSAPP EXTRACTION PROMPT
 # ══════════════════════════════════════════════════════════════════════════════
 
-WHATSAPP_EXTRACTION_PROMPT = """
-You are a support knowledge base curator.
+WHATSAPP_EXTRACTION_PROMPT = """You are a support knowledge base curator for the Iris field staff management app used in Zimbabwe.
+
+Your task: analyse this WhatsApp support group chat segment and extract ONLY clear problem→solution pairs.
 
-You have been given a raw WhatsApp group chat export from a support team.
-Your job is to extract ONLY clear problem→solution pairs.
+CONTEXT ABOUT THIS APP:
+- "Iris" is a mobile attendance/location tracking app used by field sales reps at retail stores.
+- Common issues: GPS location not detected, clock-in failures, app killed by Android battery optimiser,
+  teller passkey problems, hours not recording correctly, store radius too small, wrong teller name shown.
+- Messages mix English, Shona, and Ndebele. Understand regional vernacular (e.g. "irikudzima" = switching off,
+  "ndakashanda" = I worked, "short yemahours" = hours shortage, "gadzirisayi" = fix it through).
+- If screenshots show Android error dialogs (e.g. "Service killed by system", "App stopped"), reason through
+  what that means for Android background restriction and include it in the solution.
 
-Rules:
-- Ignore greetings, off-topic chatter, emoji-only messages, system notifications.
-- Extract only exchanges where a user described an issue AND a support agent (or another user) provided a working solution.
-- Each article must be self-contained and searchable.
-- Merge follow-up messages that belong to the same resolution thread.
+STRICT RULES:
+1. Extract ONLY exchanges where a user described a problem AND a named support person (Tendayi, Tony, Violet,
+   Rufaro, Albrighton, Ishmael, or any named responder) provided a working solution or clear instruction.
+2. Ignore: greetings, media-only messages, deleted messages, clock-in screenshots with no text context,
+   messages from unknown numbers with no solution attached.
+3. Each article must be self-contained and usable by a support agent in future.
+4. Translate all Shona/Ndebele problem descriptions to English in the article content.
+5. If a screenshot appears to show an Android error or GPS issue, reason through the likely cause and
+   include that reasoning in the solution content.
 
-Return a STRICT JSON array. Each object:
-{
-  "title": "Short, searchable title of the issue",
-  "content": "Full explanation: what the problem was and the step-by-step solution",
-  "category": "One of: Account, Billing, Technical, Feature, Other",
-  "tags": ["array", "of", "relevant", "keywords"]
-}
+OUTPUT FORMAT: Return ONLY a valid JSON array. No preamble, no explanation, no markdown fences.
+Every string value MUST be properly JSON-escaped. Do not use unescaped newlines, tabs, or quotes inside strings.
+Use \\n for line breaks within content strings.
 
-Return ONLY the JSON array, no other text.
+Schema per item:
+{"title": "string (max 80 chars)", "content": "string (escaped, solution steps)", "category": "one of: Account|Technical|Location|Attendance|Device|Other", "tags": ["array", "of", "strings"]}
 
-WhatsApp Export:
+If no valid problem→solution pairs exist in this segment, return an empty array: []
+
+Chat segment:
 """
 
+
+def _process_chunk_with_gemini(chunk: Dict) -> List[Dict]:
+    """
+    Send a single chunk (text + optional images) to Gemini.
+    Returns validated list of article dicts.
+    """
+    text_part  = WHATSAPP_EXTRACTION_PROMPT + chunk["text"]
+    images     = chunk.get("images", [])
+
+    if images and _gemini_client:
+        # Build multimodal content list
+        parts = [text_part]
+        for img_bytes in images:
+            # Detect mime type from magic bytes
+            mime = "image/jpeg"
+            if img_bytes[:4] == b'\x89PNG':
+                mime = "image/png"
+            elif img_bytes[:4] == b'RIFF':
+                mime = "image/webp"
+            parts.append(
+                genai_types.Part.from_bytes(data=img_bytes, mime_type=mime)
+            )
+        raw = _gemini_multimodal(parts, json_mode=True)
+    else:
+        raw = _gemini_text(text_part, json_mode=True)
+
+    if not raw:
+        logger.warning("Empty Gemini response for chunk")
+        return []
+
+    parsed = _safe_json(raw, [])
+    return _validate_articles(parsed)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# FEATURE 1 — WhatsApp Export → Knowledge Base (v1.1: ZIP multimodal + chunked)
+# ══════════════════════════════════════════════════════════════════════════════
+
 @app.post("/api/kb/whatsapp-import")
 def whatsapp_import():
     """
-    POST body: { "chat_text": "<raw WhatsApp export text>" }
-    Extracts problem→solution pairs, saves new articles (additive, no overwrite).
+    Accepts EITHER:
+      (a) multipart file upload with field "file" containing a .zip WhatsApp export, OR
+      (b) JSON body { "chat_text": "..." } for plain text (legacy support)
+
+    Processes in sliding-window chunks, sends images to Gemini multimodally.
+    Saves new articles only (additive, dedup by fingerprint).
     """
-    body     = request.get_json(silent=True) or {}
-    raw_chat = body.get("chat_text", "").strip()
+    all_articles: List[Dict] = []
+    source_label = "whatsapp_export"
 
-    if not raw_chat:
-        return jsonify({"ok": False, "error": "chat_text is required"}), 400
+    # ── Branch A: ZIP upload ──────────────────────────────────────────────────
+    if "file" in request.files:
+        f        = request.files["file"]
+        filename = f.filename or ""
+        if not filename.lower().endswith(".zip"):
+            return jsonify({"ok": False, "error": "Expected a .zip WhatsApp export file"}), 400
 
-    if len(raw_chat) < 100:
-        return jsonify({"ok": False, "error": "Chat export too short to process"}), 400
+        zip_bytes = f.read()
+        logger.info("WhatsApp ZIP upload: %d bytes, filename=%s", len(zip_bytes), filename)
 
-    logger.info("WhatsApp import: %d chars received", len(raw_chat))
+        processor = WhatsAppZipProcessor(zip_bytes)
+        if not processor.extract():
+            return jsonify({"ok": False, "error": "Could not extract chat from ZIP. Ensure it is a valid WhatsApp export."}), 400
 
-    gemini_out = _gemini_text(WHATSAPP_EXTRACTION_PROMPT + raw_chat[:50000], json_mode=True)
-    articles   = _safe_json(gemini_out, [])
+        if len(processor.chat_text) < 100:
+            return jsonify({"ok": False, "error": "Extracted chat text too short to process"}), 400
 
-    if not isinstance(articles, list):
-        return jsonify({"ok": False, "error": "Gemini returned unexpected format", "raw": gemini_out[:500]}), 500
+        chunks = processor.build_chunks()
+        source_label = f"whatsapp_zip:{filename}"
 
-    stats = _save_kb_articles(articles, source_label="whatsapp_export")
-    logger.info("WhatsApp import complete: %s", stats)
+        for idx, chunk in enumerate(chunks):
+            logger.info("Processing chunk %d/%d", idx + 1, len(chunks))
+            articles = _process_chunk_with_gemini(chunk)
+            all_articles.extend(articles)
+            logger.info("Chunk %d yielded %d articles (running total: %d)", idx + 1, len(articles), len(all_articles))
+
+    # ── Branch B: Legacy plain text JSON body ─────────────────────────────────
+    else:
+        body     = request.get_json(silent=True) or {}
+        raw_chat = body.get("chat_text", "").strip()
+        if not raw_chat:
+            return jsonify({"ok": False, "error": "Provide a .zip file upload or chat_text in JSON body"}), 400
+        if len(raw_chat) < 100:
+            return jsonify({"ok": False, "error": "Chat text too short to process"}), 400
+
+        logger.info("WhatsApp plain text import: %d chars", len(raw_chat))
+
+        # Chunk the plain text too (handles large exports)
+        lines  = raw_chat.splitlines()
+        pseudo_zip = type("PseudoZip", (), {
+            "chat_text": raw_chat,
+            "media_map": {}
+        })()
+        processor = WhatsAppZipProcessor(b"")
+        processor.chat_text = raw_chat
+        processor.media_map = {}
+        chunks = processor.build_chunks()
+
+        for idx, chunk in enumerate(chunks):
+            logger.info("Processing text chunk %d/%d", idx + 1, len(chunks))
+            articles = _process_chunk_with_gemini(chunk)
+            all_articles.extend(articles)
+
+    if not all_articles:
+        logger.info("No articles extracted from this export")
+        return jsonify({
+            "ok": True,
+            "articles_found": 0,
+            "saved": 0,
+            "skipped_dupes": 0,
+            "note": "No clear problem→solution pairs found in this chat segment"
+        })
+
+    stats = _save_kb_articles(all_articles, source_label=source_label)
+    logger.info("WhatsApp import complete: found=%d, %s", len(all_articles), stats)
 
     return jsonify({
-        "ok":              True,
-        "articles_found":  len(articles),
-        "saved":           stats["saved"],
-        "skipped_dupes":   stats["skipped"],
+        "ok":             True,
+        "articles_found": len(all_articles),
+        "saved":          stats["saved"],
+        "skipped_dupes":  stats["skipped"],
     })
 
 
@@ -278,7 +622,6 @@ def whatsapp_import():
 # ══════════════════════════════════════════════════════════════════════════════
 
 def _extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:
-    """Extract text from a PDF using pypdf, fallback to Gemini vision."""
     if PYPDF_AVAILABLE:
         try:
             reader = pypdf.PdfReader(io.BytesIO(pdf_bytes))
@@ -288,12 +631,9 @@ def _extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:
                 return text
         except Exception as e:
             logger.warning("pypdf extraction failed: %s", e)
-
-    # Gemini inline_data fallback for scanned PDFs
     if _gemini_client:
         try:
-            b64_pdf = base64.b64encode(pdf_bytes).decode()
-            resp    = _gemini_client.models.generate_content(
+            resp = _gemini_client.models.generate_content(
                 model=GEMINI_MODEL,
                 contents=[
                     "Extract all text from this PDF document. Return plain text only.",
@@ -306,61 +646,41 @@ def _extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:
     return ""
 
 
-PDF_KB_PROMPT = """
-You are a support knowledge base curator.
+PDF_KB_PROMPT = """You are a support knowledge base curator.
 Convert the following document content into structured KB articles.
-Each article should cover one distinct topic, issue, or procedure.
+Each article covers one distinct topic, issue, or procedure.
 
-Return a STRICT JSON array. Each object:
-{
-  "title": "Short, searchable title",
-  "content": "Complete explanation in clear language",
-  "category": "One of: Account, Billing, Technical, Feature, Other",
-  "tags": ["keyword1", "keyword2"]
-}
+Return ONLY a valid JSON array — no preamble, no markdown fences.
+All string values must be properly JSON-escaped (no raw newlines inside strings, use \\n).
 
-Return ONLY the JSON array.
+Schema per item:
+{"title": "string", "content": "string", "category": "one of: Account|Billing|Technical|Feature|Other", "tags": ["string"]}
 
 Document content:
 """
 
 @app.post("/api/kb/bulk-upload")
 def bulk_upload():
-    """
-    Accepts multipart file upload. Supports: .csv, .xlsx, .xls, .pdf
-    CSV/Excel expected columns: title, content (+ optional: category, tags)
-    PDF: Gemini extracts and structures articles.
-    """
     if "file" not in request.files:
         return jsonify({"ok": False, "error": "No file uploaded"}), 400
-
     f         = request.files["file"]
     filename  = f.filename or ""
     ext       = filename.rsplit(".", 1)[-1].lower()
     file_data = f.read()
-
-    articles = []
+    articles  = []
 
     if ext in ("csv", "xlsx", "xls"):
         if not PANDAS_AVAILABLE:
             return jsonify({"ok": False, "error": "pandas not installed on server"}), 500
         try:
-            if ext == "csv":
-                df = pd.read_csv(io.BytesIO(file_data))
-            else:
-                df = pd.read_excel(io.BytesIO(file_data))
-
+            df = pd.read_csv(io.BytesIO(file_data)) if ext == "csv" else pd.read_excel(io.BytesIO(file_data))
             df.columns = [c.strip().lower() for c in df.columns]
-
             if "title" not in df.columns or "content" not in df.columns:
                 return jsonify({"ok": False, "error": "CSV/Excel must have 'title' and 'content' columns"}), 400
-
             for _, row in df.iterrows():
                 tags = []
                 if "tags" in df.columns and pd.notna(row.get("tags")):
-                    raw_tags = str(row["tags"])
-                    tags = [t.strip() for t in re.split(r"[,;|]", raw_tags) if t.strip()]
-
+                    tags = [t.strip() for t in re.split(r"[,;|]", str(row["tags"])) if t.strip()]
                 articles.append({
                     "title":    str(row["title"]).strip(),
                     "content":  str(row["content"]).strip(),
@@ -368,100 +688,75 @@ def bulk_upload():
                     "tags":     tags,
                 })
         except Exception as e:
-            logger.error("Spreadsheet parse error: %s", e)
             return jsonify({"ok": False, "error": f"Could not parse file: {e}"}), 400
 
     elif ext == "pdf":
         text = _extract_text_from_pdf_bytes(file_data)
         if not text:
             return jsonify({"ok": False, "error": "Could not extract text from PDF"}), 400
-
-        gemini_out = _gemini_text(PDF_KB_PROMPT + text[:50000], json_mode=True)
-        articles   = _safe_json(gemini_out, [])
-
-        if not isinstance(articles, list):
-            return jsonify({"ok": False, "error": "Gemini PDF structuring failed"}), 500
+        raw     = _gemini_text(PDF_KB_PROMPT + text[:50000], json_mode=True)
+        parsed  = _safe_json(raw, [])
+        articles = _validate_articles(parsed)
+        if not articles:
+            return jsonify({"ok": False, "error": "Gemini PDF structuring returned no valid articles"}), 500
     else:
-        return jsonify({"ok": False, "error": f"Unsupported file type: .{ext}. Use csv, xlsx, or pdf"}), 400
+        return jsonify({"ok": False, "error": f"Unsupported file type .{ext}. Use csv, xlsx, or pdf"}), 400
 
     if not articles:
         return jsonify({"ok": False, "error": "No articles extracted from file"}), 400
 
     stats = _save_kb_articles(articles, source_label=f"bulk_upload:{filename}")
-    return jsonify({
-        "ok":             True,
-        "articles_found": len(articles),
-        "saved":          stats["saved"],
-        "skipped_dupes":  stats["skipped"],
-    })
+    return jsonify({"ok": True, "articles_found": len(articles), "saved": stats["saved"], "skipped_dupes": stats["skipped"]})
 
 
 # ══════════════════════════════════════════════════════════════════════════════
 # FEATURE 3 — Ticket Submission via NL Text or Voice
 # ══════════════════════════════════════════════════════════════════════════════
 
-TICKET_EXTRACTION_PROMPT = """
-You are a support ticket intake system for a software support portal.
+TICKET_EXTRACTION_PROMPT = """You are a support ticket intake system for a software support portal.
 
 A user has described their issue in natural language. Extract structured ticket fields.
 
-Return STRICT JSON (no other text):
-{
-  "title": "Concise ticket title (max 80 chars)",
-  "description": "Full detailed description of the issue, rewritten clearly in third person",
-  "category_hint": "Best matching category: Account | Billing | Technical | Feature | Other",
-  "priority_hint": "One of: low | medium | high | critical (based on urgency language)",
-  "keywords": ["array", "of", "technical", "keywords"]
-}
+Return ONLY a valid JSON object — no preamble, no markdown fences.
+All string values must be properly JSON-escaped.
 
-User's message:
+Schema:
+{"title": "string (max 80 chars)", "description": "string (full clear description)", "category_hint": "one of: Account|Billing|Technical|Feature|Other", "priority_hint": "one of: low|medium|high|critical", "keywords": ["string"]}
+
+User message:
 """
 
 def _transcribe_audio_assemblyai(audio_b64: str, audio_format: str = "wav") -> str:
-    """Upload audio to AssemblyAI and poll for transcript."""
     if not ASSEMBLYAI_API_KEY:
         return ""
-
     audio_bytes = base64.b64decode(audio_b64)
     headers     = {"authorization": ASSEMBLYAI_API_KEY}
-
-    # 1. Upload
     try:
         upload_resp = requests.post(
             f"{ASSEMBLYAI_BASE}/upload",
             headers={**headers, "Content-Type": "application/octet-stream"},
-            data=audio_bytes,
-            timeout=30
+            data=audio_bytes, timeout=30
         )
         upload_resp.raise_for_status()
         upload_url = upload_resp.json().get("upload_url")
     except Exception as e:
         logger.error("AssemblyAI upload error: %s", e)
         return ""
-
-    # 2. Request transcript
     try:
         tx_resp = requests.post(
             f"{ASSEMBLYAI_BASE}/transcript",
             headers={**headers, "Content-Type": "application/json"},
-            json={"audio_url": upload_url, "language_detection": True},
-            timeout=15
+            json={"audio_url": upload_url, "language_detection": True}, timeout=15
         )
         tx_resp.raise_for_status()
         tx_id = tx_resp.json().get("id")
     except Exception as e:
         logger.error("AssemblyAI transcript request error: %s", e)
         return ""
-
-    # 3. Poll
     for _ in range(30):
         time.sleep(3)
         try:
-            poll = requests.get(
-                f"{ASSEMBLYAI_BASE}/transcript/{tx_id}",
-                headers=headers,
-                timeout=15
-            )
+            poll   = requests.get(f"{ASSEMBLYAI_BASE}/transcript/{tx_id}", headers=headers, timeout=15)
             poll.raise_for_status()
             result = poll.json()
             status = result.get("status")
@@ -477,74 +772,47 @@ def _transcribe_audio_assemblyai(audio_b64: str, audio_format: str = "wav") -> s
 
 @app.post("/api/tickets/submit-nl")
 def submit_ticket_nl():
-    """
-    POST body: { "message": "I can't log in, it says my account is locked...", "user_id": "..." }
-    Returns structured ticket fields for the frontend to pre-fill and submit.
-    """
     body    = request.get_json(silent=True) or {}
     message = body.get("message", "").strip()
     user_id = body.get("user_id", "anonymous")
-
     if not message:
         return jsonify({"ok": False, "error": "message is required"}), 400
-
-    gemini_out = _gemini_text(TICKET_EXTRACTION_PROMPT + message, json_mode=True)
-    ticket     = _safe_json(gemini_out, {})
-
-    if not ticket.get("title"):
+    raw    = _gemini_text(TICKET_EXTRACTION_PROMPT + message, json_mode=True)
+    ticket = _safe_json(raw, {})
+    if not isinstance(ticket, dict) or not ticket.get("title"):
         return jsonify({"ok": False, "error": "Could not extract ticket info from message"}), 500
-
-    # Log submission attempt
     if db:
         db.collection("iris_ai_ticket_drafts").add({
-            "user_id":    user_id,
-            "raw_input":  message,
-            "extracted":  ticket,
-            "channel":    "nl_text",
+            "user_id": user_id, "raw_input": message,
+            "extracted": ticket, "channel": "nl_text",
             "created_at": datetime.now(timezone.utc).isoformat(),
         })
-
     return jsonify({"ok": True, "ticket": ticket})
 
 
 @app.post("/api/tickets/submit-voice")
 def submit_ticket_voice():
-    """
-    POST body: { "audio_b64": "<base64 audio>", "audio_format": "wav", "user_id": "..." }
-    Transcribes audio via AssemblyAI, then extracts ticket via Gemini.
-    """
     body         = request.get_json(silent=True) or {}
     audio_b64    = body.get("audio_b64", "")
     audio_format = body.get("audio_format", "wav")
     user_id      = body.get("user_id", "anonymous")
-
     if not audio_b64:
         return jsonify({"ok": False, "error": "audio_b64 is required"}), 400
-
     if not ASSEMBLYAI_API_KEY:
         return jsonify({"ok": False, "error": "AssemblyAI not configured on server"}), 500
-
-    logger.info("Voice ticket: transcribing audio for user=%s", user_id)
     transcript = _transcribe_audio_assemblyai(audio_b64, audio_format)
-
     if not transcript:
         return jsonify({"ok": False, "error": "Transcription failed or returned empty result"}), 500
-
-    gemini_out = _gemini_text(TICKET_EXTRACTION_PROMPT + transcript, json_mode=True)
-    ticket     = _safe_json(gemini_out, {})
-
-    if not ticket.get("title"):
+    raw    = _gemini_text(TICKET_EXTRACTION_PROMPT + transcript, json_mode=True)
+    ticket = _safe_json(raw, {})
+    if not isinstance(ticket, dict) or not ticket.get("title"):
         return jsonify({"ok": False, "error": "Could not extract ticket info from transcript"}), 500
-
     if db:
         db.collection("iris_ai_ticket_drafts").add({
-            "user_id":    user_id,
-            "raw_input":  transcript,
-            "extracted":  ticket,
-            "channel":    "voice",
+            "user_id": user_id, "raw_input": transcript,
+            "extracted": ticket, "channel": "voice",
             "created_at": datetime.now(timezone.utc).isoformat(),
         })
-
     return jsonify({"ok": True, "transcript": transcript, "ticket": ticket})
 
 
@@ -552,32 +820,22 @@ def submit_ticket_voice():
 # FEATURE 4 — System Tutorial Ingestion
 # ══════════════════════════════════════════════════════════════════════════════
 
-TUTORIAL_EXTRACTION_PROMPT = """
-You are a knowledge base curator for a software support system.
+TUTORIAL_EXTRACTION_PROMPT = """You are a knowledge base curator for a software support system.
 
-You have been given a timestamped transcript from a video tutorial about the Iris Support Portal.
-Your job is to extract discrete how-to articles, one per distinct feature or task demonstrated.
+You have a timestamped transcript from a tutorial video about the Iris Support Portal.
+Extract one KB article per distinct feature or task demonstrated.
 
-For each article, identify the best timestamp range where the solution or demonstration occurs.
+Return ONLY a valid JSON array — no preamble, no markdown fences.
+All strings must be properly JSON-escaped.
 
-Return a STRICT JSON array. Each object:
-{
-  "title": "How to <do something> in Iris",
-  "content": "Step-by-step instructions based on the tutorial",
-  "category": "One of: Account | Tickets | Agents | Reports | Admin | Other",
-  "tags": ["keyword1", "keyword2"],
-  "timestamp_start": <seconds as integer>,
-  "timestamp_end": <seconds as integer>
-}
+Schema per item:
+{"title": "string", "content": "string (step-by-step instructions)", "category": "one of: Account|Tickets|Agents|Reports|Admin|Other", "tags": ["string"], "timestamp_start": <integer seconds>, "timestamp_end": <integer seconds>}
 
-Return ONLY the JSON array.
-
-Transcript (with timestamps in [MM:SS] or [HH:MM:SS] format):
+Transcript:
 """
 
 def _parse_timestamp_to_seconds(ts: str) -> int:
-    """Convert MM:SS or HH:MM:SS string to integer seconds."""
-    parts = ts.strip("[]").split(":")
+    parts = str(ts).strip("[]").split(":")
     try:
         if len(parts) == 2:
             return int(parts[0]) * 60 + int(parts[1])
@@ -587,169 +845,101 @@ def _parse_timestamp_to_seconds(ts: str) -> int:
         pass
     return 0
 
-
 @app.post("/api/kb/tutorial-ingest")
 def tutorial_ingest():
-    """
-    POST body: {
-      "transcript": "<timestamped transcript text>",
-      "video_url": "https://...",   (optional, for linking crop timestamps)
-      "video_title": "Getting Started with Iris"
-    }
-    Gemini extracts how-to articles with timestamp ranges.
-    """
     body        = request.get_json(silent=True) or {}
     transcript  = body.get("transcript", "").strip()
     video_url   = body.get("video_url", "")
     video_title = body.get("video_title", "Tutorial")
-
     if not transcript:
         return jsonify({"ok": False, "error": "transcript is required"}), 400
-
-    logger.info("Tutorial ingest: %d chars, title=%s", len(transcript), video_title)
-
-    gemini_out = _gemini_text(TUTORIAL_EXTRACTION_PROMPT + transcript[:50000], json_mode=True)
-    articles   = _safe_json(gemini_out, [])
-
-    if not isinstance(articles, list):
-        return jsonify({"ok": False, "error": "Gemini returned unexpected format"}), 500
-
-    # Inject video metadata into each article
+    raw      = _gemini_text(TUTORIAL_EXTRACTION_PROMPT + transcript[:50000], json_mode=True)
+    parsed   = _safe_json(raw, [])
+    articles = _validate_articles(parsed) if isinstance(parsed, list) else []
+    if not articles:
+        return jsonify({"ok": False, "error": "Gemini returned no valid articles from transcript"}), 500
     for a in articles:
         a["video_url"]   = video_url
         a["video_title"] = video_title
-        # Ensure numeric seconds (Gemini may return the parsed value; validate it)
         for ts_key in ("timestamp_start", "timestamp_end"):
             val = a.get(ts_key)
             if isinstance(val, str):
                 a[ts_key] = _parse_timestamp_to_seconds(val)
             elif not isinstance(val, int):
                 a[ts_key] = 0
-
     stats = _save_kb_articles(articles, source_label=f"tutorial:{video_title}")
-
-    return jsonify({
-        "ok":             True,
-        "video_title":    video_title,
-        "articles_found": len(articles),
-        "saved":          stats["saved"],
-        "skipped_dupes":  stats["skipped"],
-    })
+    return jsonify({"ok": True, "video_title": video_title, "articles_found": len(articles), "saved": stats["saved"], "skipped_dupes": stats["skipped"]})
 
 
 # ══════════════════════════════════════════════════════════════════════════════
 # FEATURE 5 — Agent Solution Writing (NL Text + Voice)
 # ══════════════════════════════════════════════════════════════════════════════
 
-SOLUTION_EXTRACTION_PROMPT = """
-You are a support knowledge base curator.
-
-An agent or support staff has described a solution they discovered while resolving a ticket.
+SOLUTION_EXTRACTION_PROMPT = """You are a support knowledge base curator.
+An agent has described a solution they used to resolve a ticket.
 Structure this into a reusable KB article.
 
-Return STRICT JSON:
-{
-  "title": "Short, searchable problem title",
-  "content": "Clear step-by-step solution, rewritten for future reference",
-  "category": "One of: Account | Billing | Technical | Feature | Other",
-  "tags": ["relevant", "keywords"]
-}
+Return ONLY a valid JSON object — no preamble, no markdown fences.
+All strings must be properly JSON-escaped.
+
+Schema:
+{"title": "string", "content": "string (clear step-by-step solution)", "category": "one of: Account|Billing|Technical|Feature|Other", "tags": ["string"]}
 
-Agent's description:
+Agent description:
 """
 
 @app.post("/api/kb/agent-solution-nl")
 def agent_solution_nl():
-    """
-    POST body: { "message": "I fixed ticket #123 by...", "agent_id": "...", "ticket_id": "..." }
-    Creates a KB article from agent's natural language solution description.
-    """
     body      = request.get_json(silent=True) or {}
     message   = body.get("message", "").strip()
     agent_id  = body.get("agent_id", "unknown")
     ticket_id = body.get("ticket_id", "")
-
     if not message:
         return jsonify({"ok": False, "error": "message is required"}), 400
-
-    gemini_out = _gemini_text(SOLUTION_EXTRACTION_PROMPT + message, json_mode=True)
-    article    = _safe_json(gemini_out, {})
-
-    if not article.get("title"):
+    raw     = _gemini_text(SOLUTION_EXTRACTION_PROMPT + message, json_mode=True)
+    article = _safe_json(raw, {})
+    if not isinstance(article, dict) or not article.get("title"):
         return jsonify({"ok": False, "error": "Could not structure solution"}), 500
-
-    # Add ticket reference tag
     if ticket_id:
         article.setdefault("tags", []).append(f"ticket:{ticket_id}")
-
     stats = _save_kb_articles([article], source_label=f"agent:{agent_id}")
-
-    return jsonify({
-        "ok":     True,
-        "saved":  stats["saved"],
-        "article": article,
-    })
+    return jsonify({"ok": True, "saved": stats["saved"], "article": article})
 
 
 @app.post("/api/kb/agent-solution-voice")
 def agent_solution_voice():
-    """
-    POST body: { "audio_b64": "...", "audio_format": "wav", "agent_id": "...", "ticket_id": "..." }
-    Transcribes agent's voice note, structures into KB article.
-    """
     body         = request.get_json(silent=True) or {}
     audio_b64    = body.get("audio_b64", "")
     audio_format = body.get("audio_format", "wav")
     agent_id     = body.get("agent_id", "unknown")
     ticket_id    = body.get("ticket_id", "")
-
     if not audio_b64:
         return jsonify({"ok": False, "error": "audio_b64 is required"}), 400
-
     transcript = _transcribe_audio_assemblyai(audio_b64, audio_format)
-
     if not transcript:
         return jsonify({"ok": False, "error": "Transcription failed"}), 500
-
-    gemini_out = _gemini_text(SOLUTION_EXTRACTION_PROMPT + transcript, json_mode=True)
-    article    = _safe_json(gemini_out, {})
-
-    if not article.get("title"):
+    raw     = _gemini_text(SOLUTION_EXTRACTION_PROMPT + transcript, json_mode=True)
+    article = _safe_json(raw, {})
+    if not isinstance(article, dict) or not article.get("title"):
         return jsonify({"ok": False, "error": "Could not structure solution from transcript"}), 500
-
     if ticket_id:
         article.setdefault("tags", []).append(f"ticket:{ticket_id}")
-
     stats = _save_kb_articles([article], source_label=f"agent:{agent_id}")
-
-    return jsonify({
-        "ok":        True,
-        "transcript": transcript,
-        "saved":     stats["saved"],
-        "article":   article,
-    })
+    return jsonify({"ok": True, "transcript": transcript, "saved": stats["saved"], "article": article})
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-# FEATURE 6 — Iris Support Chatbot (RAG over KB + Tutorials)
+# FEATURE 6 — Iris Chatbot (RAG over KB + Tutorials)
 # ══════════════════════════════════════════════════════════════════════════════
 
 def _search_kb(query: str, limit: int = 5) -> List[Dict]:
-    """
-    Simple keyword search over Firestore KB articles.
-    Production upgrade: swap with a vector DB (e.g. Qdrant) or Vertex AI Search.
-    """
     if not db:
         return []
-
     query_terms = [t.lower() for t in query.split() if len(t) > 2]
-
     try:
-        # Fetch recent articles (Firestore doesn't support full-text, this is a lightweight approach)
         docs = db.collection("iris_kb_articles").order_by(
             "created_at", direction=firestore.Query.DESCENDING
         ).limit(200).stream()
-
         results = []
         for doc in docs:
             d     = doc.to_dict()
@@ -757,60 +947,40 @@ def _search_kb(query: str, limit: int = 5) -> List[Dict]:
             score = sum(1 for term in query_terms if term in text)
             if score > 0:
                 results.append({"score": score, **d})
-
         results.sort(key=lambda x: x["score"], reverse=True)
         return results[:limit]
-
     except Exception as e:
         logger.error("KB search error: %s", e)
         return []
 
 
-CHATBOT_SYSTEM_PROMPT = """
-You are Iris, an intelligent support assistant for the Iris Support Portal.
+CHATBOT_SYSTEM_PROMPT = """You are Iris, an intelligent support assistant for the Iris Support Portal.
 
-Your role: Help users resolve issues quickly using the knowledge base and tutorial content provided.
-
-Rules:
-- Answer ONLY from the provided context. Do not hallucinate solutions.
-- If the answer is in a tutorial with a timestamp, mention the video and timestamp so the user can jump to that moment.
-- Be concise, clear, and friendly.
-- If you cannot find the answer, say so honestly and suggest submitting a ticket.
-- Format step-by-step answers as numbered lists.
+Answer ONLY from the provided knowledge base context.
+If the answer is in a tutorial with a timestamp, mention the video and timestamp.
+Be concise, clear, and friendly. Format step-by-step answers as numbered lists.
+If you cannot find the answer, say so honestly and suggest submitting a ticket.
 """
 
 @app.post("/api/chatbot/query")
 def chatbot_query():
-    """
-    POST body: {
-      "message": "How do I reset a user's password?",
-      "session_id": "...",
-      "user_id": "..."
-    }
-    RAG: searches KB, then uses Gemini to synthesize an answer.
-    """
     body       = request.get_json(silent=True) or {}
     message    = body.get("message", "").strip()
     session_id = body.get("session_id", "default")
     user_id    = body.get("user_id", "anonymous")
-
     if not message:
         return jsonify({"ok": False, "error": "message is required"}), 400
-
-    # Retrieve relevant KB context
     kb_results = _search_kb(message, limit=5)
-
     context_blocks = []
     sources        = []
     for r in kb_results:
         block = f"[Article: {r.get('title')}]\n{r.get('content', '')}"
         if r.get("timestamp_start") is not None:
-            ts  = r["timestamp_start"]
-            mm  = ts // 60
-            ss  = ts % 60
-            url = r.get("video_url", "")
-            block += f"\n(Tutorial: {r.get('video_title','Video')} at {mm:02d}:{ss:02d}"
-            block += f" — {url})" if url else ")"
+            ts = r["timestamp_start"]
+            block += f"\n(Tutorial: {r.get('video_title','Video')} at {ts//60:02d}:{ts%60:02d}"
+            if r.get("video_url"):
+                block += f" — {r['video_url']}"
+            block += ")"
         context_blocks.append(block)
         sources.append({
             "title":     r.get("title"),
@@ -819,75 +989,43 @@ def chatbot_query():
             "ts_start":  r.get("timestamp_start"),
             "video_url": r.get("video_url"),
         })
-
-    context_str = "\n\n---\n\n".join(context_blocks) if context_blocks else "No relevant articles found."
-
-    full_prompt = f"""{CHATBOT_SYSTEM_PROMPT}
-
-KNOWLEDGE BASE CONTEXT:
-{context_str}
-
-USER QUESTION: {message}
-
-Answer:"""
-
-    answer = _gemini_text(full_prompt)
-
+    context_str  = "\n\n---\n\n".join(context_blocks) if context_blocks else "No relevant articles found."
+    full_prompt  = f"{CHATBOT_SYSTEM_PROMPT}\n\nKNOWLEDGE BASE CONTEXT:\n{context_str}\n\nUSER QUESTION: {message}\n\nAnswer:"
+    answer       = _gemini_text(full_prompt)
     if not answer:
-        answer = "I'm sorry, I couldn't process your question right now. Please try again or submit a support ticket."
-
-    # Persist chat log
+        answer = "Sorry, I could not process your question right now. Please try again or submit a support ticket."
     if db:
         db.collection("iris_chatbot_logs").add({
-            "user_id":    user_id,
-            "session_id": session_id,
-            "message":    message,
-            "answer":     answer,
-            "sources":    sources,
+            "user_id": user_id, "session_id": session_id,
+            "message": message, "answer": answer, "sources": sources,
             "created_at": datetime.now(timezone.utc).isoformat(),
         })
-
-    return jsonify({
-        "ok":      True,
-        "answer":  answer,
-        "sources": sources,
-    })
+    return jsonify({"ok": True, "answer": answer, "sources": sources})
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-# KB READ ENDPOINTS (for frontend display)
+# KB READ / DELETE ENDPOINTS
 # ══════════════════════════════════════════════════════════════════════════════
 
 @app.get("/api/kb/articles")
 def list_kb_articles():
-    """
-    GET /api/kb/articles?category=Technical&limit=50
-    Lists KB articles, optionally filtered by category.
-    """
     category = request.args.get("category", "")
     limit    = int(request.args.get("limit", 50))
-
     if not db:
         return jsonify({"ok": False, "error": "Firebase unavailable"}), 500
-
     try:
-        query = db.collection("iris_kb_articles").order_by(
-            "created_at", direction=firestore.Query.DESCENDING
-        )
+        query = db.collection("iris_kb_articles").order_by("created_at", direction=firestore.Query.DESCENDING)
         if category:
             query = query.where("category", "==", category)
-
         docs     = query.limit(limit).stream()
         articles = [{"id": d.id, **d.to_dict()} for d in docs]
         return jsonify({"ok": True, "articles": articles, "count": len(articles)})
     except Exception as e:
-        logger.error("KB list error: %s", e)
         return jsonify({"ok": False, "error": str(e)}), 500
 
 
 @app.delete("/api/kb/articles/<article_id>")
 def delete_kb_article(article_id: str):
-    """DELETE /api/kb/articles/<id> — Admin only (JWT check to be enforced at gateway)"""
     if not db:
         return jsonify({"ok": False, "error": "Firebase unavailable"}), 500
     try:
@@ -910,14 +1048,14 @@ def health():
             article_count = docs[0][0].value
         except Exception:
             pass
-
     return jsonify({
-        "ok":              True,
-        "service":         "Iris AI Service v1.0",
-        "gemini":          bool(_gemini_client),
-        "assemblyai":      bool(ASSEMBLYAI_API_KEY),
-        "firebase":        bool(db),
-        "kb_articles":     article_count,
+        "ok":          True,
+        "service":     "Iris AI Service v1.1",
+        "model":       GEMINI_MODEL,
+        "gemini":      bool(_gemini_client),
+        "assemblyai":  bool(ASSEMBLYAI_API_KEY),
+        "firebase":    bool(db),
+        "kb_articles": article_count,
     })
 
 
@@ -927,5 +1065,5 @@ def health():
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    logger.info("Iris AI Service starting on port %d", port)
+    logger.info("Iris AI Service v1.1 starting on port %d (model=%s)", port, GEMINI_MODEL)
     app.run(host="0.0.0.0", port=port)