Restore: Revert codebase to stable May 14th 6 PM state

.env.example

@@ -1,19 +1,34 @@
-LLM_PROVIDER=fireworks
-FIREWORKS_API_KEY=your_fireworks_api_key
-FIREWORKS_MODEL=accounts/fireworks/models/qwen3-32b
-FIREWORKS_REWRITE_MODEL=accounts/fireworks/models/llama-v3p1-8b-instruct
+LLM_PROVIDER=openai
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-4o-mini
+OPENAI_REWRITE_MODEL=gpt-4o-mini
+
 GROQ_API_KEY=your_groq_api_key
 GROQ_MODEL=qwen/qwen3-32b
 GROQ_REWRITE_MODEL=llama-3.1-8b-instant
+
+FIREWORKS_API_KEY=your_fireworks_api_key
+FIREWORKS_MODEL=accounts/fireworks/models/qwen3-30b-a3b-instruct-2507
+FIREWORKS_REWRITE_MODEL=accounts/fireworks/models/qwen3-8b
+
 HF_API_KEY=your_huggingface_api_key
 HF_MODEL=meta-llama/Llama-3.1-8B-Instruct
 EMBEDDING_MODEL=BAAI/bge-small-en-v1.5
+RERANKER_MODEL=cross-encoder/ms-marco-MiniLM-L-6-v2
+
 DOCS_DIR=docs
 INDEX_DIR=data/index
 SESSIONS_DIR=data/sessions
-TOP_K=4
+TOP_K=8
+
 CORS_ALLOW_ORIGINS=*
-API_KEY=
+API_KEY=your_internal_api_key
 RATE_LIMIT_REQUESTS=60
 RATE_LIMIT_WINDOW_SECONDS=60
-RAG_API_URL=
+
+# SMTP Settings for OTP
+SMTP_SERVER=smtp.gmail.com
+SMTP_PORT=465
+SMTP_USER=
+SMTP_PASS=
+ADMIN_EMAIL=randomjoedown@gmail.com

app/admin/templates/admin.html

@@ -7,6 +7,7 @@
   <title>Martechsol — Admin Panel</title>
   <link rel="preconnect" href="https://fonts.googleapis.com" />
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
   <style>
     *,
     *::before,
@@ -312,10 +313,23 @@
       border: 1px solid var(--border);
       border-radius: 8px;
       margin-top: 4px;
-      display: none;
       z-index: 100;
       box-shadow: var(--shadow);
       overflow: hidden;
+      /* Smooth show/hide with max-height + opacity */
+      max-height: 0;
+      opacity: 0;
+      visibility: hidden;
+      transition: max-height .35s ease, opacity .25s ease, visibility 0s .35s;
+      pointer-events: none;
+    }
+
+    .export-menu.open {
+      max-height: 200px;
+      opacity: 1;
+      visibility: visible;
+      transition: max-height .35s ease, opacity .25s ease, visibility 0s 0s;
+      pointer-events: auto;
     }
 
     .export-menu button {
@@ -335,10 +349,6 @@
       color: var(--text)
     }
 
-    .export-dropdown:hover .export-menu {
-      display: block
-    }
-
     .search-wrap {
       padding: 12px 16px;
       border-bottom: 1px solid var(--border)
@@ -630,6 +640,163 @@
       color: #fca5a5
     }
 
+    /* ── Export Modal ── */
+    .export-modal-overlay {
+      position: fixed;
+      inset: 0;
+      background: rgba(0,0,0,.6);
+      backdrop-filter: blur(4px);
+      z-index: 10000;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      opacity: 0;
+      visibility: hidden;
+      transition: opacity .25s ease, visibility 0s .25s;
+    }
+    .export-modal-overlay.open {
+      opacity: 1;
+      visibility: visible;
+      transition: opacity .25s ease, visibility 0s 0s;
+    }
+    .export-modal {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 16px;
+      padding: 32px 28px;
+      width: 380px;
+      box-shadow: 0 20px 60px rgba(0,0,0,.6);
+      transform: translateY(16px) scale(.97);
+      transition: transform .25s ease;
+    }
+    .export-modal-overlay.open .export-modal {
+      transform: translateY(0) scale(1);
+    }
+    .export-modal-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      margin-bottom: 22px;
+    }
+    .export-modal-header h3 {
+      font-size: 15px;
+      font-weight: 700;
+      background: linear-gradient(135deg, var(--accent), var(--accent2));
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+    .export-modal-close {
+      background: none;
+      border: none;
+      color: var(--text3);
+      cursor: pointer;
+      font-size: 20px;
+      line-height: 1;
+      transition: color .2s;
+      padding: 2px 6px;
+      border-radius: 6px;
+    }
+    .export-modal-close:hover { color: var(--text); background: var(--surface2); }
+    .export-modal-section {
+      margin-bottom: 20px;
+    }
+    .export-modal-label {
+      font-size: 11px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: .07em;
+      color: var(--text3);
+      margin-bottom: 10px;
+    }
+    .export-radio-group {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+    .export-radio-option {
+      display: flex;
+      align-items: flex-start;
+      gap: 10px;
+      padding: 11px 14px;
+      border-radius: 10px;
+      border: 1px solid var(--border);
+      background: var(--surface2);
+      cursor: pointer;
+      transition: all .2s;
+    }
+    .export-radio-option:hover {
+      border-color: rgba(59,130,246,.4);
+      background: rgba(59,130,246,.05);
+    }
+    .export-radio-option input[type=radio] {
+      margin-top: 1px;
+      accent-color: var(--accent);
+      width: 15px;
+      height: 15px;
+      flex-shrink: 0;
+      cursor: pointer;
+    }
+    .export-radio-option.selected {
+      border-color: rgba(59,130,246,.5);
+      background: rgba(59,130,246,.08);
+    }
+    .export-radio-text strong {
+      font-size: 13px;
+      font-weight: 600;
+      color: var(--text);
+      display: block;
+    }
+    .export-radio-text span {
+      font-size: 11px;
+      color: var(--text3);
+      margin-top: 2px;
+      display: block;
+    }
+    .export-format-group {
+      display: flex;
+      gap: 8px;
+    }
+    .export-format-btn {
+      flex: 1;
+      padding: 9px 12px;
+      border-radius: 9px;
+      border: 1px solid var(--border);
+      background: var(--surface2);
+      color: var(--text2);
+      font-size: 12px;
+      font-weight: 600;
+      font-family: inherit;
+      cursor: pointer;
+      transition: all .2s;
+      text-align: center;
+    }
+    .export-format-btn:hover { border-color: rgba(59,130,246,.4); color: var(--text); }
+    .export-format-btn.active {
+      border-color: var(--accent);
+      background: rgba(59,130,246,.12);
+      color: var(--accent);
+    }
+    .btn-export-modal-submit {
+      width: 100%;
+      padding: 12px;
+      border: none;
+      border-radius: 10px;
+      background: linear-gradient(135deg, var(--accent), var(--accent2));
+      color: #fff;
+      font-size: 14px;
+      font-weight: 600;
+      font-family: inherit;
+      cursor: pointer;
+      transition: opacity .2s, transform .15s;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      margin-top: 4px;
+    }
+    .btn-export-modal-submit:hover { opacity: .88; transform: translateY(-1px); }
+    .btn-export-modal-submit:disabled { opacity: .5; cursor: not-allowed; transform: none; }
+
     /* ── Animations ── */
     @keyframes fadeUp {
       from {
@@ -746,18 +913,12 @@
         </div>
       </div>
       <div class="sidebar-actions">
-        <div class="export-dropdown">
-          <button class="btn-export">
-            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3" />
-            </svg>
-            Export All
-          </button>
-          <div class="export-menu">
-            <button id="btn-export-all-excel">Excel (.xlsx)</button>
-            <button id="btn-export-all-json">JSON (.json)</button>
-          </div>
-        </div>
+        <button class="btn-export" id="btn-open-export-modal" style="flex:1">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3" />
+          </svg>
+          Export Chat
+        </button>
       </div>
       <div class="search-wrap">
         <input type="text" id="search-inp" placeholder="Search sessions…" />
@@ -807,6 +968,55 @@
 
   <div class="toast" id="toast"></div>
 
+  <!-- Export Modal -->
+  <div class="export-modal-overlay" id="export-modal-overlay">
+    <div class="export-modal" role="dialog" aria-modal="true" aria-labelledby="export-modal-title">
+      <div class="export-modal-header">
+        <h3 id="export-modal-title">Export Chat History</h3>
+        <button class="export-modal-close" id="export-modal-close" aria-label="Close">&times;</button>
+      </div>
+
+      <div class="export-modal-section">
+        <div class="export-modal-label">Export Scope</div>
+        <div class="export-radio-group">
+          <label class="export-radio-option selected" id="radio-label-one">
+            <input type="radio" name="export-scope" value="one" id="export-scope-one" checked />
+            <div class="export-radio-text">
+              <strong>All sessions in one file</strong>
+              <span>Combines every session into a single export file</span>
+            </div>
+          </label>
+          <label class="export-radio-option" id="radio-label-sep">
+            <input type="radio" name="export-scope" value="separate" id="export-scope-separate" />
+            <div class="export-radio-text">
+              <strong>Each session as a separate file</strong>
+              <span>Downloads a ZIP archive containing one file per session</span>
+            </div>
+          </label>
+        </div>
+      </div>
+
+      <div class="export-modal-section">
+        <div class="export-modal-label">File Format</div>
+        <div class="export-format-group">
+          <button class="export-format-btn active" id="fmt-excel" data-fmt="excel">
+            📊 Excel (.xlsx)
+          </button>
+          <button class="export-format-btn" id="fmt-json" data-fmt="json">
+            🗂️ JSON (.json)
+          </button>
+        </div>
+      </div>
+
+      <button class="btn-export-modal-submit" id="btn-export-modal-submit">
+        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2">
+          <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3" />
+        </svg>
+        Export Now
+      </button>
+    </div>
+  </div>
+
   <script>
     (function () {
       const CREDS = { user: 'martech_admin', pass: 'martech_admin_303' };
@@ -1111,38 +1321,135 @@
         } catch (e) { showToast('Delete failed: ' + e.message, 'error') }
       });
 
-      // ── Exports ───────────────────────────────────────────────
-      async function downloadExport(url, filename) {
-        try {
-          const r = await fetch(url, { headers: { Authorization: authHeader() } });
-          if (!r.ok) throw new Error('Export failed');
-          const blob = await r.blob();
-          const link = document.createElement('a');
-          link.href = window.URL.createObjectURL(blob);
-          link.download = filename;
-          link.click();
-          showToast('Export successful', 'success');
-        } catch (e) {
-          showToast('Export failed: ' + e.message, 'error');
+      // ── Export Session (header) dropdown hover logic ───────���──
+      document.querySelectorAll('.export-dropdown').forEach(dropdown => {
+        const menu = dropdown.querySelector('.export-menu');
+        let hideTimer = null;
+        function showMenu() { clearTimeout(hideTimer); menu.classList.add('open'); }
+        function scheduleHide() {
+          clearTimeout(hideTimer);
+          hideTimer = setTimeout(() => menu.classList.remove('open'), 300);
         }
-      }
-
-      $('btn-export-all-excel').addEventListener('click', () => {
-        downloadExport('/api/admin/export/all?format=excel', 'all_chats_export.xlsx');
+        dropdown.addEventListener('mouseenter', showMenu);
+        dropdown.addEventListener('mouseleave', scheduleHide);
+        menu.addEventListener('mouseenter', showMenu);
+        menu.addEventListener('mouseleave', scheduleHide);
+        menu.querySelectorAll('button').forEach(btn => {
+          btn.addEventListener('click', () => { clearTimeout(hideTimer); menu.classList.remove('open'); });
+        });
       });
 
-      $('btn-export-all-json').addEventListener('click', () => {
-        downloadExport('/api/admin/export/all?format=json', 'all_chats_export.json');
-      });
+      // ── Exports — shared download helper ──────────────────────
+      async function downloadExport(url, filename) {
+        const r = await fetch(url, { headers: { Authorization: authHeader() } });
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        const blob = await r.blob();
+        const a = document.createElement('a');
+        a.href = URL.createObjectURL(blob);
+        a.download = filename;
+        a.click();
+      }
 
+      // ── Session header export (unchanged behaviour) ────────────
       $('btn-export-session-excel').addEventListener('click', () => {
         if (!_activeId) return;
-        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=excel`, `session_${_activeId}.xlsx`);
+        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=excel`,
+          `session_${_activeId}.xlsx`).then(() => showToast('Export successful', 'success'))
+          .catch(e => showToast('Export failed: ' + e.message, 'error'));
       });
-
       $('btn-export-session-json').addEventListener('click', () => {
         if (!_activeId) return;
-        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=json`, `session_${_activeId}.json`);
+        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=json`,
+          `session_${_activeId}.json`).then(() => showToast('Export successful', 'success'))
+          .catch(e => showToast('Export failed: ' + e.message, 'error'));
+      });
+
+      // ── Sidebar Export Modal ───────────────────────────────────
+      let _exportFmt = 'excel'; // active format selection
+
+      function openExportModal() {
+        $('export-modal-overlay').classList.add('open');
+      }
+      function closeExportModal() {
+        $('export-modal-overlay').classList.remove('open');
+      }
+
+      $('btn-open-export-modal').addEventListener('click', openExportModal);
+      $('export-modal-close').addEventListener('click', closeExportModal);
+      $('export-modal-overlay').addEventListener('click', e => {
+        if (e.target === $('export-modal-overlay')) closeExportModal();
+      });
+      document.addEventListener('keydown', e => {
+        if (e.key === 'Escape') closeExportModal();
+      });
+
+      // Radio option highlight
+      document.querySelectorAll('input[name="export-scope"]').forEach(radio => {
+        radio.addEventListener('change', () => {
+          $('radio-label-one').classList.toggle('selected', $('export-scope-one').checked);
+          $('radio-label-sep').classList.toggle('selected', $('export-scope-separate').checked);
+        });
+      });
+
+      // Format toggle buttons
+      document.querySelectorAll('.export-format-btn').forEach(btn => {
+        btn.addEventListener('click', () => {
+          document.querySelectorAll('.export-format-btn').forEach(b => b.classList.remove('active'));
+          btn.classList.add('active');
+          _exportFmt = btn.dataset.fmt;
+        });
+      });
+
+      // Submit export
+      $('btn-export-modal-submit').addEventListener('click', async () => {
+        const scope = document.querySelector('input[name="export-scope"]:checked').value;
+        const fmt = _exportFmt;
+        const btn = $('btn-export-modal-submit');
+        btn.disabled = true;
+        btn.innerHTML = '<span style="display:inline-block;width:14px;height:14px;border:2px solid rgba(255,255,255,.3);border-top-color:#fff;border-radius:50%;animation:spin .6s linear infinite"></span> Exporting…';
+
+        try {
+          if (scope === 'one') {
+            // Single file — existing endpoint
+            const ext = fmt === 'excel' ? 'xlsx' : 'json';
+            await downloadExport(`/api/admin/export/all?format=${fmt}`, `all_chats_export.${ext}`);
+            showToast('Export successful', 'success');
+            closeExportModal();
+          } else {
+            // Separate files → ZIP
+            if (!_allSessions.length) { showToast('No sessions to export', 'error'); return; }
+            const zip = new JSZip();
+            const ext = fmt === 'excel' ? 'xlsx' : 'json';
+            let done = 0;
+            for (const s of _allSessions) {
+              try {
+                const r = await fetch(
+                  `/api/admin/export/session/${encodeURIComponent(s.session_id)}?format=${fmt}`,
+                  { headers: { Authorization: authHeader() } }
+                );
+                if (r.ok) {
+                  const blob = await r.blob();
+                  const safeName = (s.user_name || s.session_id).replace(/[^a-z0-9_\-]/gi, '_');
+                  zip.file(`${safeName}_${s.session_id.slice(-6)}.${ext}`, blob);
+                  done++;
+                }
+              } catch {/* skip failed sessions */}
+            }
+            if (!done) throw new Error('No sessions could be exported');
+            const zipBlob = await zip.generateAsync({ type: 'blob' });
+            const a = document.createElement('a');
+            a.href = URL.createObjectURL(zipBlob);
+            a.download = `chat_export_${new Date().toISOString().slice(0,10)}.zip`;
+            a.click();
+            showToast(`Exported ${done} session${done !== 1 ? 's' : ''} as ZIP`, 'success');
+            closeExportModal();
+          }
+        } catch (e) {
+          showToast('Export failed: ' + e.message, 'error');
+        } finally {
+          btn.disabled = false;
+          btn.innerHTML = '<svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3" /></svg> Export Now';
+        }
       });
 
     })();

app/core/config.py

@@ -31,13 +31,13 @@ class Settings(BaseSettings):
             self.index_dir = Path("/data/index")
             self.sessions_dir = Path("/data/sessions")
         return self
-
+    
     index_dir: Path = Field(default=Path("data/index"), alias="INDEX_DIR")
     sessions_dir: Path = Field(default=Path("data/sessions"), alias="SESSIONS_DIR")
     chunk_size_tokens: int = 350  # Reduced for TPM safety
     chunk_overlap_tokens: int = 80
-    top_k: int = Field(default=15, alias="TOP_K")  # Increased to 15 to capture more candidates for reranking
-    max_context_chunks: int = 12  # Increased to 12 to ensure exhaustive lists (like all leave types) are fully captured
+    top_k: int = Field(default=8, alias="TOP_K")  
+    max_context_chunks: int = 4  # _build_context() caps at 1500 words anyway; 4 chunks is sufficient
     request_timeout_s: float = 20.0
     cors_allow_origins: str = Field(default="*", alias="CORS_ALLOW_ORIGINS")
     api_key: str = Field(default="", alias="API_KEY")

app/main.py

@@ -34,6 +34,9 @@ vector_store = FaissVectorStore(
 )
 llm_service = LLMService(
     provider=settings.llm_provider,
+    openai_api_key=settings.openai_api_key,
+    openai_model=settings.openai_model,
+    openai_rewrite_model=settings.openai_rewrite_model,
     groq_api_key=settings.groq_api_key,
     groq_model=settings.groq_model,
     groq_rewrite_model=settings.groq_rewrite_model,
@@ -42,9 +45,6 @@ llm_service = LLMService(
     fireworks_api_key=settings.fireworks_api_key,
     fireworks_model=settings.fireworks_model,
     fireworks_rewrite_model=settings.fireworks_rewrite_model,
-    openai_api_key=settings.openai_api_key,
-    openai_model=settings.openai_model,
-    openai_rewrite_model=settings.openai_rewrite_model,
     timeout_s=settings.request_timeout_s,
 )
 reranker_service = RerankerService(settings.reranker_model)
@@ -176,10 +176,12 @@ async def chat(
         
         error_msg = "⚠️ Oops! Something went wrong."
         if isinstance(e, httpx.HTTPStatusError):
-            if e.response.status_code == 429:
-                error_msg = "⚠️ Rate limit reached. Please slow down a bit!"
-            else:
-                error_msg = "⚠️ I encountered an error. Please try again in a few seconds."
+            try:
+                error_data = e.response.json()
+                api_msg = error_data.get("error", {}).get("message", e.response.text)
+            except Exception:
+                api_msg = e.response.text
+            error_msg = f"⚠️ API Error ({e.response.status_code}): {api_msg}"
                 
         return ChatResponse(reply=error_msg, retrieved_chunks=[])
 

app/services/llm.py

@@ -9,82 +9,102 @@ _log = logging.getLogger(__name__)
 # MASTER SYSTEM PROMPT — Martechsol HR Assistant
 # Intelligence: Understand Intent → Retrieve Facts → Respond Precisely
 # ═══════════════════════════════════════════════════════════════════════
-SYSTEM_PROMPT = """You are the Martechsol HR Assistant — intelligent, precise, and formal.
+SYSTEM_PROMPT = """You are the Martechsol HR Assistant — a highly intelligent, professional HR expert.
+You give precise, concise answers using ONLY the relevant parts of the Expert Data provided.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-CORE REFERENCE DATA (Leave Entitlements)
+RULE 0 — FILTER THE CONTEXT FIRST
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-• Casual Leave: 10 days
-• Sick Leave: 8 days
-• Annual Leave: 14 days
-• Maternity Leave: 90 days (Female only)
-• Paternity Leave: 3 days (Male only)
-• Bereavement Leave: 3 days
-• Hajj Leave: 30 days
+The Expert Data may contain multiple topics. Before answering:
+✦ Identify which parts are DIRECTLY relevant to the question.
+✦ IGNORE everything else — do not include unrelated policies in your answer.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-STEP 1 — UNDERSTAND THE INTENT
+RULE 1 — ANSWER INTELLIGENTLY (like a real HR expert would)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Read the question carefully. Identify the core topics (could be multiple). Apply workplace logic:
-• "timing" / "timings" (no context) → office working hours ONLY.
-• "leaves" / "leave" (no context) → leave names + day counts ONLY.
-• "paid leaves" / "all leaves" → enumerate EVERY leave type with its name and count.
-• "salary" / "pay" (no context) → salary structure or amount.
-• "benefits" / "perks" / "allowances" → list EVERY benefit with its name and value.
-• "terminate" / "termination" → resignation/termination procedure.
-If a question has an obvious workplace context, always default to the most common interpretation.
+Understand the user's INTENT and respond accordingly:
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-STEP 2 — SCOPE & INTELLIGENCE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Answer ONLY what was asked using the Expert Data. Use intelligence to bridge logical gaps:
-• EXHAUSTIVE LISTS: For "all leaves" or "paid leaves," you MUST list EVERY single leave type found in the Expert Data. Omitting even one (like **Annual Leave** or **Hajj Leave**) is a failure. Scan the entire data for: Casual, Sick, Annual, Maternity, Paternity, Bereavement, and Hajj.
-• ALTERNATIVES: If a user is ineligible (e.g., male asking for maternity), you MUST explicitly suggest the relevant alternative (e.g., **Paternity Leave**) from the data.
-• CONCLUSIONS: If the user mentions a specific number (e.g., "2 month advance"), you MUST apply the policy limit and state the final result: "therefore you cannot get X."
-• MANAGEMENT: If the data states a manager "approves" or "manages" leaves, it implies they have the authority to reject, cancel, or postpone them based on business needs.
-• NOTIFICATION: If the data describes a "requirement" to inform HR, conclude that failure to do so is a violation of that process.
-• AUTHORITY: Keep answers direct. No conversational fillers or source references.
-• CACHE VERSION: v3 (intelligence boost active).
+• "casual leaves" → give a brief summary (entitlement, carry forward, encashment) in 1-2 sentences.
+• "i want to take casual leave" → explain HOW to apply/take leave (the procedure).
+• "can I resign?" → answer YES or NO, then explain briefly.
+• "list all leaves" / "all paid leaves" → enumerate every type with its count.
+• "how to apply for sick leave?" → give the step-by-step process.
+
+Think about WHAT the user actually needs, not just what topic they mentioned.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-STEP 3 — FORMAT DECISION TABLE (MANDATORY)
+RULE 2 — FORMAT (use the simplest format that fits)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  QUESTION TYPE                          → FORMAT TO USE
-  ─────────────────────────────────────────────────────
-  "how many X leaves?"                   → FORMAT A (one number only)
-  "what is X leave / eligibility?"       → FORMAT A (one sentence, count + 1 key fact)
-  "how to apply / how to get X leave"    → FORMAT C (procedure for THAT leave ONLY)
-  "what are all leaves / list all X"     → FORMAT B (full exhaustive list)
-  "paid leaves / all paid leaves"        → FORMAT B (full exhaustive list)
-  "what is the policy for X?"            → FORMAT C (policy for THAT leave ONLY)
-  "and X?" (follow-up in conversation)   → FORMAT A (answer only the new X)
+■ PARAGRAPH (default — use for most answers):
+  1-3 complete sentences. Bold key values with <b>bold</b>.
 
-FORMAT A — SINGLE FACT
-  Rule: ONE complete sentence. Maximum 25–30 words. Never cut mid-sentence.
-  Example: You are entitled to <b>8 Sick Leave</b> days per year.
+■ KEY-VALUE LIST (only for enumerating 4+ items):
+  <b>Item Name:</b> value<br>
+  <b>Item Name:</b> value<br>
 
-FORMAT B — EXHAUSTIVE LIST
-  Rule: Include EVERY single item found. No intro/outro. One item per line: <b>Item:</b> value<br>
+■ STRUCTURED LIST (only for step-by-step procedures):
+  <ul>
+  <li><b>Step 1:</b> description.</li>
+  <li><b>Step 2:</b> description.</li>
+  </ul>
 
-FORMAT C — BRIEF EXPLANATION (procedure / how-to)
-  Rule: Answer ONLY for the SPECIFIC topic. Maximum 3 bullet points. No filler.
+Do NOT use a list when a paragraph works. Do NOT use <br> inside <li> tags.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-STRICT QUALITY RULES
+RULE 3 — QUALITY
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✓ ZERO hallucination — every fact must exist in Expert Data only. No guessing.
-✓ If not in Expert Data → reply exactly: "I don't have that information."
-✓ Never cut a sentence mid-way — always complete every sentence fully
-✓ NEVER mention: "document", "handbook", "manual", "policy file", or any source reference
-✓ Use <b>bold</b> for names, numbers, dates, leave types, and all key terms
-✓ Use <br> between list items for clean vertical spacing
-✓ Tone: formal, warm, and professional — never robotic, never chatty
-✓ Do NOT add greetings, closings, or "Is there anything else?" type phrases"""
-
-
-
-def _build_context(chunks: List[Dict[str, str]], max_words: int = 3000) -> str:
+✓ Every fact MUST exist in the Expert Data. No guessing.
+✓ If the answer is not in Expert Data → say: "I don't have that information."
+✓ NEVER mention: "document", "handbook", "manual", or any source name.
+✓ Be concise. Do not over-explain or repeat yourself.
+✓ Tone: formal, warm, and confident — like a knowledgeable HR advisor.
+✓ Do NOT add greetings or closing phrases."""
+
+# ── Universal HTML Post-Processor ────────────────────────────────────────────
+# Called by ALL providers (Groq, Fireworks, OpenAI) to ensure clean output.
+def _clean_html(content: str) -> str:
+    """Sanitize LLM HTML output: fix spacing, strip filler, clean tags."""
+    # 1. Strip <think>...</think> blocks (Qwen3, DeepSeek-R1)
+    content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
+
+    # 2. Fix <br> placement: remove <br> that appears BEFORE </li>
+    content = re.sub(r'<br\s*/?>\s*</li>', '</li>', content, flags=re.IGNORECASE)
+
+    # 3. Remove <br> right before </ul> (trailing br after last li)
+    content = re.sub(r'<br\s*/?>\s*</ul>', '</ul>', content, flags=re.IGNORECASE)
+
+    # 4. Collapse double+ <br> into single <br>
+    content = re.sub(r'(<br\s*/?>\s*){2,}', '<br>', content, flags=re.IGNORECASE)
+
+    # 5. Strip leading/trailing whitespace and newlines
+    content = content.strip()
+
+    # 6. Strip leading conversational filler
+    content = re.sub(
+        r'^(Okay[,.]?\s*|Alright[,.]?\s*|Sure[,.]?\s*|Let\'s see[,.]?\s*|'
+        r'Based on (?:the )?(?:provided |available )?(?:data|information|context)[,.]?\s*|'
+        r'According to (?:the )?(?:provided |available )?(?:data|information)[,.]?\s*)',
+        '', content, flags=re.IGNORECASE
+    ).strip()
+
+    # 7. Remove self-talk lines (thinking-model artifacts)
+    lines = content.split('\n')
+    filtered = []
+    for line in lines:
+        is_self_talk = bool(re.match(
+            r'^\s*(I need to|I will|I should|I\'m going to|Let me|Now I|First,? I|'
+            r'I\'ll|The user is asking|The question is about)',
+            line, re.IGNORECASE
+        ))
+        if not is_self_talk:
+            filtered.append(line)
+    content = '\n'.join(filtered).strip()
+
+    return content
+
+
+def _build_context(chunks: List[Dict[str, str]], max_words: int = 1500) -> str:
     """Combines retrieved chunks into a clean context string, capped at max_words.
     Prevents TPM spikes when chunks are unexpectedly large."""
     if not chunks:
@@ -109,32 +129,32 @@ def _build_context(chunks: List[Dict[str, str]], max_words: int = 3000) -> str:
 class LLMService:
     def __init__(
         self,
-        provider: str,
-        groq_api_key: str,
-        groq_model: str,
-        groq_rewrite_model: str,
-        hf_api_key: str,
-        hf_model: str,
-        fireworks_api_key: str = "",
-        fireworks_model: str = "accounts/fireworks/models/qwen3-32b",
-        fireworks_rewrite_model: str = "accounts/fireworks/models/llama-v3p1-8b-instruct",
+        provider: str = "openai",
+        groq_api_key: str = "",
+        groq_model: str = "qwen/qwen3-32b",
+        groq_rewrite_model: str = "llama-3.1-8b-instant",
         openai_api_key: str = "",
         openai_model: str = "gpt-4o-mini",
         openai_rewrite_model: str = "gpt-4o-mini",
+        hf_api_key: str = "",
+        hf_model: str = "meta-llama/Llama-3.1-8B-Instruct",
+        fireworks_api_key: str = "",
+        fireworks_model: str = "accounts/fireworks/models/qwen3-32b",
+        fireworks_rewrite_model: str = "accounts/fireworks/models/llama-v3p1-8b-instruct",
         timeout_s: float = 20.0,
     ) -> None:
         self.provider = provider.lower().strip()
         self.groq_api_key = groq_api_key
         self.groq_model = groq_model
         self.groq_rewrite_model = groq_rewrite_model
+        self.openai_api_key = openai_api_key
+        self.openai_model = openai_model
+        self.openai_rewrite_model = openai_rewrite_model
         self.hf_api_key = hf_api_key
         self.hf_model = hf_model
         self.fireworks_api_key = fireworks_api_key
         self.fireworks_model = fireworks_model
         self.fireworks_rewrite_model = fireworks_rewrite_model
-        self.openai_api_key = openai_api_key
-        self.openai_model = openai_model
-        self.openai_rewrite_model = openai_rewrite_model
         self.timeout_s = timeout_s
         # Persistent client — reused across all calls; eliminates TCP+TLS handshake per request
         self._client = httpx.AsyncClient(
@@ -194,9 +214,10 @@ Queries:"""
                 for q in resp.split("\n")
                 if q.strip() and len(q.strip()) > 3
             ]
-            # Always include original query
-            if query not in queries:
-                queries.append(query)
+            # Always ensure the original query is the FIRST and prioritized search term
+            if query in queries:
+                queries.remove(query)
+            queries.insert(0, query)
             return queries[:3]
         except Exception:
             return [query]
@@ -225,7 +246,7 @@ Queries:"""
 
         if self.provider == "fireworks":
             return await self._call_fireworks(user_prompt, pruned_history, system_msg)
-        if self.provider == "openai":
+        elif self.provider == "openai":
             return await self._call_openai(user_prompt, pruned_history, system_msg)
         return await self._call_groq(user_prompt, pruned_history, system_msg)
 
@@ -276,32 +297,8 @@ Queries:"""
         data = resp.json()
         content = data["choices"][0]["message"]["content"].strip()
 
-        # ── Post-Processing: Strip all internal reasoning artifacts ──
-
-        # 1. Strip <think>...</think> blocks (Qwen3, DeepSeek-R1)
-        content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
-
-        # 2. Strip leading conversational filler (single line only, not entire content)
-        content = re.sub(
-            r'^(Okay[,.]?\s*|Alright[,.]?\s*|Sure[,.]?\s*|Let\'s see[,.]?\s*|'
-            r'Based on (?:the )?(?:provided |available )?(?:data|information|context)[,.]?\s*|'
-            r'According to (?:the )?(?:provided |available )?(?:data|information)[,.]?\s*)',
-            '', content, flags=re.IGNORECASE
-        ).strip()
-
-        # 3. Remove lines that are pure internal self-talk (only if they appear alone at start)
-        lines = content.split('\n')
-        filtered = []
-        for i, line in enumerate(lines):
-            is_self_talk = bool(re.match(
-                r'^\s*(I need to|I will|I should|I\'m going to|Let me|Now I|First,? I|'
-                r'I\'ll|The user is asking|The question is about)',
-                line, re.IGNORECASE
-            ))
-            if not is_self_talk:
-                filtered.append(line)
-        content = '\n'.join(filtered).strip()
-
+        # ── Post-Processing ──────────────────────────────────────────────────
+        content = _clean_html(content)
         return content
 
     async def _call_fireworks(
@@ -355,32 +352,8 @@ Queries:"""
         data = resp.json()
         content = data["choices"][0]["message"]["content"].strip()
 
-        # ── Post-Processing: identical pipeline as Groq path ──
-
-        # 1. Strip <think>...</think> blocks (Qwen3)
-        content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
-
-        # 2. Strip leading conversational filler
-        content = re.sub(
-            r'^(Okay[,.]?\s*|Alright[,.]?\s*|Sure[,.]?\s*|Let\'s see[,.]?\s*|'
-            r'Based on (?:the )?(?:provided |available )?(?:data|information|context)[,.]?\s*|'
-            r'According to (?:the )?(?:provided |available )?(?:data|information)[,.]?\s*)',
-            '', content, flags=re.IGNORECASE
-        ).strip()
-
-        # 3. Remove lines that are pure internal self-talk
-        lines = content.split('\n')
-        filtered = []
-        for line in lines:
-            is_self_talk = bool(re.match(
-                r'^\s*(I need to|I will|I should|I\'m going to|Let me|Now I|First,? I|'
-                r'I\'ll|The user is asking|The question is about)',
-                line, re.IGNORECASE
-            ))
-            if not is_self_talk:
-                filtered.append(line)
-        content = '\n'.join(filtered).strip()
-
+        # ── Post-Processing ──────────────────────────────────────────────────
+        content = _clean_html(content)
         return content
 
     async def _call_openai(
@@ -409,7 +382,7 @@ Queries:"""
         payload = {
             "model": target_model,
             "temperature": 0.0,
-            "max_tokens": 800,
+            "max_tokens": 512,
             "messages": messages,
         }
 
@@ -420,26 +393,6 @@ Queries:"""
         data = resp.json()
         content = data["choices"][0]["message"]["content"].strip()
 
-        # ── Post-Processing ──
-        # Strip leading conversational filler
-        content = re.sub(
-            r'^(Okay[,.]?\s*|Alright[,.]?\s*|Sure[,.]?\s*|Let\'s see[,.]?\s*|'
-            r'Based on (?:the )?(?:provided |available )?(?:data|information|context)[,.]?\s*|'
-            r'According to (?:the )?(?:provided |available )?(?:data|information)[,.]?\s*)',
-            '', content, flags=re.IGNORECASE
-        ).strip()
-
-        # Remove lines that are pure internal self-talk
-        lines = content.split('\n')
-        filtered = []
-        for line in lines:
-            is_self_talk = bool(re.match(
-                r'^\s*(I need to|I will|I should|I\'m going to|Let me|Now I|First,? I|'
-                r'I\'ll|The user is asking|The question is about)',
-                line, re.IGNORECASE
-            ))
-            if not is_self_talk:
-                filtered.append(line)
-        content = '\n'.join(filtered).strip()
-
+        # ── Post-Processing (unified) ────────────────
+        content = _clean_html(content)
         return content

app/services/rag_pipeline.py

@@ -1,7 +1,8 @@
 import logging
 import hashlib
+import re
 from collections import OrderedDict
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 from app.services.llm import LLMService
 from app.services.vector_store import FaissVectorStore
@@ -9,109 +10,97 @@ from app.services.reranker import RerankerService
 
 logger = logging.getLogger(__name__)
 
-# ── In-memory LRU answer cache ──────────────────────────────────────────────
-# Keyed on MD5 of the normalized message. Holds up to 128 unique answers.
-# Clears automatically on app restart (intentional — KB could be re-indexed).
-_CACHE_MAX = 128
+# ── Answer cache DISABLED — prompt changes need to take effect immediately ───
+# Re-enable once prompt is finalized by uncommenting the OrderedDict line
+_CACHE_MAX = 0
 _answer_cache: OrderedDict = OrderedDict()
 
 
 def _cache_key(message: str) -> str:
-    """Returns a stable hash key for a normalized message string (v3 for intelligence boost)."""
-    return hashlib.md5(f"v3-{message.lower().strip()}".encode()).hexdigest()
-
-# ── Local intent-based query expander ────────────────────────────────────────
-# Replaces the async Groq API call (llama-3.1-8b-instant) with deterministic
-# Python rules — runs in microseconds, saves 3–6s per request.
-# Rules mirror the exact intent-detection logic from the old LLM prompt.
-# IMPORTANT: ordered most-specific → least-specific to prevent false matches.
-_INTENT_MAP: List[tuple] = [
-    # ── Leave types (most specific first) ──
-    ("paid leave",    ["casual leave sick leave annual leave", 
-                       "maternity paternity hajj bereavement",
-                       "paid leave types employee entitlement days count",
-                       "unauthorized absence study leave policy"]),
-    ("all leave",     ["casual leave sick leave annual leave maternity paternity hajj bereavement study unauthorized",
-                       "all leave types employee entitlement days count"]),
-    ("maternity",     ["maternity leave days duration policy eligibility female", "paid leave maternity employee"]),
-    ("paternity",     ["paternity leave days duration policy eligibility male", "paid leave paternity employee"]),
-    ("hajj",          ["hajj leave days duration policy notification HR visa", "paid leave hajj religious requirement"]),
-    ("bereavement",   ["bereavement leave death family days notification", "compassionate leave policy"]),
-    ("sick leave",    ["sick leave days count policy medical certificate", "medical leave employee entitlement"]),
-    ("casual leave",  ["casual leave days count policy notice period", "leave types employee rules"]),
-    ("annual leave",  ["annual leave days count policy accumulation encashment", "leave entitlement per year"]),
-    ("study leave",   ["study leave education policy days qualification", "employee study leave entitlement"]),
-    ("leave",         ["casual leave sick leave annual leave maternity paternity hajj bereavement study unauthorized",
-                       "leave types employee entitlement days eligibility"]),
-    # ── Management / Rights / Rejection (New Intelligence Layer) ──
-    ("reject",        ["management rights leave approval rejection authority cancel postpone", "leave application rules"]),
-    ("refuse",        ["management rights leave approval rejection authority cancel postpone", "leave application rules"]),
-    ("cancel",        ["cancel leave policy management rights postpone approved leave", "leave rules"]),
-    ("manager",       ["management rights authority supervisor approval leave rejection", "manager role leave"]),
-    ("inform",        ["employee notification obligation HR inform report notify absence", "leave application process"]),
-    ("notify",        ["employee notification obligation HR inform report notify absence", "leave application process"]),
-    ("what if",       ["consequences unauthorized absence policy rules management rights", "disciplinary action process"]),
-    # ── Office timing ──
-    ("office hour",   ["office working hours schedule", "workday start end time shift"]),
-    ("work hour",     ["office working hours schedule", "workday start end time shift"]),
-    ("timing",        ["office working hours schedule", "workday start end time hours"]),
-    ("schedule",      ["office working hours schedule", "workday start end time"]),
-    # ── Salary / Pay ──
-    ("salary",        ["salary structure payroll compensation amount advance salary", "monthly pay increment deduction"]),
-    ("pay",           ["salary structure payroll compensation", "payment date schedule advance pay"]),
-    ("payroll",       ["salary payroll structure compensation", "monthly pay deduction"]),
-    ("compensation",  ["salary compensation structure payroll", "monthly pay amount"]),
-    # ── Benefits / Allowances ──
-    ("allowance",     ["allowances perks medical bonuses fuel transport reimbursements", "employee benefits"]),
-    ("benefit",       ["allowances perks medical bonuses reimbursements", "employee benefits privileges"]),
-    ("perk",          ["employee perks benefits extras privileges", "allowances bonuses"]),
-    ("fuel",          ["fuel allowance transport reimbursement conveyance petrol"]),
-    ("medical",       ["medical allowance health insurance coverage", "medical benefits employee"]),
-    ("transport",     ["transport allowance fuel reimbursement conveyance"]),
-    ("bonus",         ["bonus performance incentive annual eid festival reward"]),
-    # ── Termination / Resignation ──
-    ("terminat",      ["termination resignation procedure process steps", "notice period exit policy"]),
-    ("resign",        ["resignation procedure steps notice period", "termination exit process"]),
-    ("notice period", ["notice period resignation termination duration days leaves during notice"]),
-    # ── Other HR topics ──
-    ("probat",        ["probation period duration conditions employee"]),
-    ("overtime",      ["overtime compensation extra hours payment policy"]),
-    ("increment",     ["salary increment raise annual review appraisal performance"]),
-    ("appraisal",     ["performance appraisal review increment salary raise"]),
-    ("attendance",    ["attendance policy punctuality late arrival absenteeism"]),
-    ("dress code",    ["dress code uniform attire professional clothing policy"]),
-    ("remote",        ["remote work work from home WFH policy telecommute evaluation"]),
-    ("grievance",     ["grievance complaint procedure policy employee rights"]),
-    ("discipline",    ["disciplinary action policy procedure employee"]),
-    ("code of conduct", ["code of conduct policy employee behaviour rules"]),
-]
-
-
-def _expand_query_locally(message: str) -> List[str]:
+    """Returns a stable hash key for a normalized message string."""
+    return hashlib.md5(message.lower().strip().encode()).hexdigest()
+
+
+# ── Generic Query Expander (no hardcoded topics) ────────────────────────────
+# Works for ANY domain automatically. Extracts core keywords from any query.
+
+_STOP_WORDS = frozenset({
+    "can", "i", "we", "you", "do", "does", "did", "the", "a", "an",
+    "is", "am", "are", "was", "were", "be", "been", "being",
+    "tell", "me", "about", "how", "what", "where", "when", "why", "who",
+    "please", "would", "could", "should", "will", "shall", "may", "might",
+    "have", "has", "had", "to", "for", "of", "in", "on", "at", "by",
+    "with", "from", "this", "that", "these", "those", "it", "its",
+    "my", "your", "our", "their", "there", "here", "if", "or", "and",
+    "but", "not", "no", "so", "get", "got", "give", "any",
+})
+
+
+def _normalize_compounds(text: str) -> str:
     """
-    Expands a user query into targeted search strings using keyword rules.
-    Replaces the async LLM rewrite call — runs in microseconds, zero API cost.
-    Mirrors the exact intent-detection logic previously in the llama-3.1-8b prompt.
+    Expands compound words like 'pro-rata' to all their variants.
+    Runs in microseconds — no network call required.
     """
-    msg_lower = message.lower()
-    queries: List[str] = [message]  # Original query always first
+    compounds = re.findall(r'\b\w+(?:[-\/]\w+)+\b', text.lower())
+    extra = ""
+    for word in compounds:
+        joined = re.sub(r'[-\/]', '', word)          # pro-rata → prorata
+        spaced = re.sub(r'[-\/]', ' ', word)          # pro-rata → pro rata
+        extra += f" {joined} {spaced}"
+    return text + extra
 
-    for keyword, variants in _INTENT_MAP:
-        if keyword in msg_lower:
-            for v in variants:
-                if v not in queries:
-                    queries.append(v)
-            # Removed break to allow multiple intent matches (e.g. "maternity" + "reject")
 
-    return queries[:6]  # Increased to 6 to handle the split leave queries effectively
+def _extract_keywords(message: str) -> str:
+    """Extract meaningful content words by removing stop words."""
+    words = message.lower().split()
+    keywords = [w for w in words if w not in _STOP_WORDS and len(w) > 1]
+    return " ".join(keywords) if keywords else message.lower()
+
+
+def _expand_query(message: str) -> Tuple[List[str], str]:
+    """
+    Generic query expansion. No hardcoded topics — works for any domain.
+    
+    Strategy:
+      1. Original query (with compound normalization)
+      2. Keywords-only version (stop words removed)
+    Both are always searched. The retriever handles the rest.
+    
+    Returns:
+        queries      – list of 1-2 search strings
+        llm_question – the original user message (passed to the LLM as-is)
+    """
+    # Normalize compound words in the original
+    normalized = _normalize_compounds(message)
+    
+    # Extract core keywords (removes "can", "i", "we", "do", etc.)
+    keywords = _extract_keywords(message)
+    keywords_normalized = _normalize_compounds(keywords)
+    
+    queries = [normalized]
+    
+    # Add keywords-only version if different from original
+    if keywords_normalized.strip() != normalized.strip().lower():
+        queries.append(keywords_normalized)
+    
+    # Always pass the original message to the LLM — let it understand naturally
+    return queries, message
+
+
+
+def _is_greeting(message: str) -> bool:
+    """Fast check for greetings to skip heavy RAG processing."""
+    greetings = {"hi", "hello", "hey", "greetings", "good morning", "good afternoon", "good evening"}
+    words = message.lower().strip().split()
+    return any(w in greetings for w in words) and len(words) <= 2
 
 
 # RRF scores are small (e.g. 0.016–0.033), so threshold must be very low
-RELEVANCE_THRESHOLD = 0.002  # Dropped further to catch all leave segments
+RELEVANCE_THRESHOLD = 0.001
 # Cross-encoder logit > 0 means > 50% relevance probability
-RERANK_THRESHOLD = -0.8    # Relaxed further to ensure the AI sees all retrieved leave types
+RERANK_THRESHOLD = 0.0
 # If ALL chunks fail rerank threshold, fall back to this many top chunks
-RERANK_FALLBACK_N = 10     # Fallback to a large number to ensure completeness for lists
+RERANK_FALLBACK_N = 2
 
 
 class RAGPipeline:
@@ -133,81 +122,67 @@ class RAGPipeline:
         # ── Cache check: return instantly for repeated identical questions ──
         key = _cache_key(message)
         if key in _answer_cache:
-            _answer_cache.move_to_end(key)  # Mark as recently used
+            _answer_cache.move_to_end(key)
             logger.info("Cache HIT for: '%s'", message[:40])
             return _answer_cache[key]
 
-        # ── Step 1: Expand query locally (no API call — instant) ──
-        queries = _expand_query_locally(message)
-        logger.info("Expanded %d queries for: '%s' → %s", len(queries), message[:40], queries)
+        # ── Step 1: Instant local query expansion (microseconds, no LLM call) ──
+        if _is_greeting(message):
+            queries = [message]
+            llm_question = message
+        else:
+            queries, llm_question = _expand_query(message)
+            logger.info("Expanded queries for: '%s' → %s", message[:40], queries)
 
-        # ── Step 2: Collect unique chunks across all queries ──
-        seen_ids = set()
-        all_retrieved = []
-
-        for q in queries:
-            query_chunks = self.vector_store.search(q, top_k=self.top_k)
-            for chunk in query_chunks:
-                if chunk["id"] not in seen_ids:
-                    all_retrieved.append(chunk)
-                    seen_ids.add(chunk["id"])
+        # ── Step 2: Batched hybrid search ──
+        all_retrieved = self.vector_store.multi_search(queries, top_k=self.top_k)
 
         # ── Step 3: Initial relevance filter ──
         initial_chunks = [c for c in all_retrieved if c["score"] >= RELEVANCE_THRESHOLD]
 
         if not initial_chunks:
-            logger.info("No relevant chunks found for: '%s' — returning no-info response", message)
-            # Pass empty chunks; LLM is instructed to say "I don't have that information"
+            logger.info("No relevant chunks for: '%s' — returning no-info response", message)
             reply = await self.llm_service.answer(
-                question=message,
+                question=llm_question,
                 chunks=[],
                 history=history,
                 user_name=user_name
             )
             return {"reply": reply, "retrieved_chunks": []}
 
-        # ── Step 4: Deep reranking via Cross-Encoder ──
-        # Enrich the reranker query with the first expanded variant (queries[1])
-        # to give the cross-encoder broader semantic context.
-        rerank_query = message
-        if len(queries) > 1:
-            rerank_query = f"{message} {queries[1]}"
-
+        # ── Step 4: Cross-Encoder Reranking ──
+        rerank_query = llm_question  # Use the enriched question for better reranking
         reranked_chunks = self.reranker.rerank(rerank_query, initial_chunks, top_n=self.max_context_chunks)
 
-        # Filter by rerank score threshold
         final_chunks = [c for c in reranked_chunks if c.get("rerank_score", 0) > RERANK_THRESHOLD]
 
-        # ── Smart Fallback: if ALL chunks fail the threshold, use the top N anyway ──
-        # This prevents the bot from saying "I don't have info" when content WAS retrieved
-        # but the cross-encoder wasn't confident enough (e.g. paraphrased queries)
+        # Smart fallback: don't say "no info" when chunks were retrieved
         if not final_chunks and reranked_chunks:
             final_chunks = reranked_chunks[:RERANK_FALLBACK_N]
             logger.info(
-                "Rerank fallback activated — all chunks below threshold (best score=%.3f), using top %d",
-                reranked_chunks[0].get("rerank_score", 0),
-                len(final_chunks)
+                "Rerank fallback — all below threshold (best=%.3f), using top %d",
+                reranked_chunks[0].get("rerank_score", 0), len(final_chunks)
             )
 
         logger.info(
-            "Pipeline: retrieved=%d → relevance_filtered=%d → reranked=%d → final=%d (best_score=%.3f)",
+            "Pipeline: retrieved=%d → filtered=%d → reranked=%d → final=%d (best=%.3f)",
             len(all_retrieved), len(initial_chunks), len(reranked_chunks), len(final_chunks),
             reranked_chunks[0].get("rerank_score", 0) if reranked_chunks else 0.0
         )
 
-        # ── Step 5: Generate answer with top-ranked context ──
+        # ── Step 5: Generate answer ──
         reply = await self.llm_service.answer(
-            question=message,
+            question=llm_question,
             chunks=final_chunks,
             history=history,
             user_name=user_name
         )
         result = {"reply": reply, "retrieved_chunks": final_chunks}
 
-        # ── Populate cache (evict oldest if at capacity) ──
+        # ── Populate LRU cache ──
         _answer_cache[key] = result
         if len(_answer_cache) > _CACHE_MAX:
-            _answer_cache.popitem(last=False)  # Remove least-recently-used
-        logger.info("Cache MISS — stored answer for: '%s'", message[:40])
+            _answer_cache.popitem(last=False)
+        logger.info("Stored answer for: '%s'", message[:40])
 
         return result

app/services/vector_store.py

@@ -11,6 +11,26 @@ from rank_bm25 import BM25Okapi
 from app.services.chunker import chunk_documents
 from app.services.document_loader import load_documents
 from app.services.embeddings import EmbeddingService
+import re
+import asyncio
+
+def _analyze(text: str) -> List[str]:
+    """Professional analyzer for RAG: lowercases, removes noise, and handles hyphens/punctuation."""
+    # 1. Lowercase
+    text = text.lower()
+    
+    # 2. Handle compound words: index "pro-rata" or "half/day" as joined "prorata", "halfday"
+    # Find all words containing hyphens or slashes
+    compounds = re.findall(r'\b\w+(?:[-\/]\w+)+\b', text)
+    for word in compounds:
+        joined = word.replace('-', '').replace('/', '')
+        text += f" {joined}"
+        
+    # 3. Final tokenization: split by non-word characters to remove punctuation but keep words
+    tokens = re.findall(r'\b\w+\b', text)
+    
+    # 4. Filter short noise tokens (optional, but keep for precision)
+    return [t for t in tokens if len(t) > 1]
 
 
 class FaissVectorStore:
@@ -41,7 +61,8 @@ class FaissVectorStore:
 
     def _compute_docs_fingerprint(self) -> str:
         hasher = hashlib.sha256()
-        # Include chunk settings in fingerprint so changing them triggers re-index
+        # Include analyzer version and chunk settings in fingerprint so changing them triggers re-index
+        hasher.update("v4_hybrid_normalizer".encode("utf-8"))  # bump this to force re-index
         hasher.update(str(self.chunk_size_tokens).encode("utf-8"))
         hasher.update(str(self.chunk_overlap_tokens).encode("utf-8"))
         
@@ -89,7 +110,7 @@ class FaissVectorStore:
         index = faiss.IndexFlatIP(dim)
         index.add(vectors)
 
-        tokenized_corpus = [c["text"].lower().split() for c in chunks]
+        tokenized_corpus = [_analyze(c["text"]) for c in chunks]
         bm25 = BM25Okapi(tokenized_corpus)
 
         self.index = index
@@ -107,54 +128,76 @@ class FaissVectorStore:
         )
 
     def search(self, query: str, top_k: int = 4) -> List[Dict[str, str]]:
-        if self.index is None or not self.metadata or self.bm25 is None:
+        """Backwards compatibility for single query search."""
+        return self.multi_search([query], top_k=top_k)
+
+    def multi_search(self, queries: List[str], top_k: int = 4) -> List[Dict[str, str]]:
+        """
+        Professional batched search:
+        1. Encodes all queries in a single batch (fast).
+        2. Searches FAISS for all vectors at once.
+        3. Runs BM25 for all queries.
+        4. Combines everything with a unified RRF pass.
+        """
+        if self.index is None or not self.metadata or self.bm25 is None or not queries:
             self.last_retrieved = []
             return []
 
-        # Vector Search (FAISS)
-        query_vec = self.embedding_service.encode_query(query)
-        faiss_scores, faiss_indices = self.index.search(np.asarray(query_vec, dtype=np.float32), top_k * 2)
-
-        # BM25 Search
-        tokenized_query = query.lower().split()
-        bm25_scores = self.bm25.get_scores(tokenized_query)
+        # 1. Batched Embedding — use encode() which handles any list size efficiently
+        query_vectors = self.embedding_service.encode(list(queries))
+        # Ensure shape is always 2D: (N, dim)
+        if query_vectors.ndim == 1:
+            query_vectors = query_vectors.reshape(1, -1)
         
-        # Get top indices for BM25
-        bm25_top_indices = np.argsort(bm25_scores)[::-1][:top_k * 2]
+        # 2. Batched FAISS Search
+        # faiss_indices shape: (len(queries), top_k*2)
+        faiss_scores, faiss_indices = self.index.search(
+            np.asarray(query_vectors, dtype=np.float32), 
+            top_k * 3 # Wider pool for better merging
+        )
 
-        # Combine using Reciprocal Rank Fusion (RRF)
-        # RRF_score = 1 / (k + rank)
+        # 3. Batched BM25 Search
+        # Combine all tokenized queries
         k = 60
         rrf_scores = {}
-        
-        # Add FAISS ranks
-        for rank, idx in enumerate(faiss_indices[0]):
-            if idx < 0 or idx >= len(self.metadata):
-                continue
-            rrf_scores[idx] = rrf_scores.get(idx, 0.0) + (1.0 / (k + rank + 1))
+
+        for q_idx, query in enumerate(queries):
+            # FAISS results for this query
+            for rank, idx in enumerate(faiss_indices[q_idx]):
+                if idx < 0 or idx >= len(self.metadata):
+                    continue
+                # Add to RRF score
+                rrf_scores[idx] = rrf_scores.get(idx, 0.0) + (1.0 / (k + rank + 1))
             
-        # Add BM25 ranks
-        for rank, idx in enumerate(bm25_top_indices):
-            if idx < 0 or idx >= len(self.metadata):
-                continue
-            rrf_scores[idx] = rrf_scores.get(idx, 0.0) + (1.0 / (k + rank + 1))
+            # BM25 results for this query
+            tokenized_query = _analyze(query)
+            bm25_scores = self.bm25.get_scores(tokenized_query)
+            bm25_top_indices = np.argsort(bm25_scores)[::-1][:top_k * 3]
+            
+            for rank, idx in enumerate(bm25_top_indices):
+                if idx < 0 or idx >= len(self.metadata) or bm25_scores[idx] <= 0:
+                    continue
+                rrf_scores[idx] = rrf_scores.get(idx, 0.0) + (1.0 / (k + rank + 1))
 
-        # Sort by combined RRF score
-        sorted_indices = sorted(rrf_scores.keys(), key=lambda x: rrf_scores[x], reverse=True)[:top_k]
+        # 4. Final Ranking
+        if not rrf_scores:
+            self.last_retrieved = []
+            return []
+
+        sorted_indices = sorted(rrf_scores.keys(), key=lambda x: rrf_scores[x], reverse=True)[:top_k * 2]
 
         results: List[Dict[str, str]] = []
         for idx in sorted_indices:
             chunk = self.metadata[idx]
-            # Fetch the original FAISS score for fallback relevance checking if needed, or just use RRF score
-            # Note: RRF scores are small (e.g. 0.03), so we must adjust the threshold in rag_pipeline
             results.append(
                 {
                     "id": chunk["id"],
                     "source": chunk["source"],
                     "text": chunk["text"],
-                    "score": float(rrf_scores[idx]), # RRF score
+                    "score": float(rrf_scores[idx]),
                 }
             )
+        
         self.last_retrieved = results
         return results