Restore to latest backup from 13 May - 2026-05-15 17:56

.env.example

@@ -1,34 +1,19 @@
-LLM_PROVIDER=openai
-OPENAI_API_KEY=your_openai_api_key
-OPENAI_MODEL=gpt-4o-mini
-OPENAI_REWRITE_MODEL=gpt-4o-mini
-
+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
 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=8
-
+TOP_K=4
 CORS_ALLOW_ORIGINS=*
-API_KEY=your_internal_api_key
+API_KEY=
 RATE_LIMIT_REQUESTS=60
 RATE_LIMIT_WINDOW_SECONDS=60
-
-# SMTP Settings for OTP
-SMTP_SERVER=smtp.gmail.com
-SMTP_PORT=465
-SMTP_USER=
-SMTP_PASS=
-ADMIN_EMAIL=randomjoedown@gmail.com
+RAG_API_URL=

CONFIG_NOTES.md

@@ -1,32 +1,29 @@
 # Configuration Backup - Martechsol RAG Chatbot
-**Date:** 2026-05-05
+**Date:** 2026-04-28
 **Source:** C:\Users\DELL\Desktop\RAG_backup2
-**Destination:** D:\RAG_Backup_2026_05_05
+**Destination:** D:\RAG_Backup_2026_04_28
 
-## Core Settings (latest state)
+## Core Settings (from app/core/config.py)
 - **App Name:** Fast RAG Chatbot
-- **LLM Provider:** openai
-- **Main LLM Model:** 4o-mini (OpenAI)
-- **Query Rewriter:** 4o-mini (OpenAI)
+- **LLM Provider:** groq (default)
+- **Groq Model:** llama-3.1-8b-instant
 - **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 Directory:** docs/
 - **Index Directory:** data/index/
 - **Sessions Directory:** data/sessions/
-- **Chunk Size:** 350 tokens (Optimized for context window)
+- **Chunk Size:** 420 tokens
 - **Overlap:** 80 tokens
-- **Top K:** 8
-- **Max Context Chunks:** 4
+- **Top K:** 4
 
 ## Admin Credentials
 - **Username:** martech_admin
 - **Password:** martech_admin_303
 - **OTP Expiry:** 300 seconds (5 minutes)
 
-## Security & Notifications
+## Security
 - **Auth Method:** HTTP Basic Auth + OTP (email-based)
-- **Admin Email:** randomjoedown@gmail.com
+- **Email for OTP:** randomjoedown@gmail.com
 - **SMTP Server:** smtp.gmail.com (Port 465)
 
 ## API / Integration
@@ -35,7 +32,7 @@
 - **Admin Endpoint:** /admin
 - **CORS:** Allowed for all (*) for testing
 
-## Optimization Notes
-- **Latency Optimization**: Skip thinking process for Qwen3 using deterministic intent detection.
-- **Conciseness Protocol**: Strict 25-30 word response limit enforced via System Prompt.
-- **Hybrid Search**: FAISS + BM25 with Reranker for high precision.
+## Infrastructure
+- **Hugging Face Path:** /data (for persistent storage)
+- **Local Path:** data/ (for local storage)
+- **Dockerfile:** Based on python:3.10-slim, serves on port 7860

README.md

@@ -14,7 +14,7 @@ Production-style document QA chatbot using:
 - FastAPI API service
 - FAISS vector search
 - SentenceTransformer embeddings (`BAAI/bge-small-en-v1.5` by default)
-- OpenAI (preferred) or Hugging Face LLM APIs
+- Groq (preferred) or Hugging Face LLM APIs
 - Optional Gradio chat UI
 
 ## Features
@@ -42,7 +42,7 @@ Production-style document QA chatbot using:
 `app/services/chunker.py` - token-window chunking  
 `app/services/embeddings.py` - embedding model wrapper  
 `app/services/vector_store.py` - FAISS index and retrieval  
-`app/services/llm.py` - OpenAI/HF LLM clients and prompt  
+`app/services/llm.py` - Groq/HF LLM clients and prompt  
 `app/services/rag_pipeline.py` - end-to-end chat flow  
 `app/ui_gradio.py` - optional web chat UI
 
@@ -61,7 +61,7 @@ copy .env.example .env
 ```
 
 Then set your keys in `.env`:
-- `OPENAI_API_KEY` (if using OpenAI)
+- `GROQ_API_KEY` (if using Groq)
 - `HF_API_KEY` (if using Hugging Face)
 - Optional:
   - `API_KEY` for request auth (send as `x-api-key`)
@@ -122,7 +122,7 @@ If you set `RAG_API_URL`, it will call that external FastAPI endpoint instead.
 
 - Works as backend for websites (REST API is frontend-agnostic)
 - Persist `data/index/` volume in production
-- Prefer OpenAI provider for low latency
+- Prefer Groq provider for low latency
 - Keep `top_k` small (3-5) for speed and lower prompt tokens
 - Protect `/chat` with `API_KEY` in production
 - Set strict `CORS_ALLOW_ORIGINS` instead of `*`
@@ -158,7 +158,7 @@ Use these settings in your Space:
 - **Python version**: 3.10+ (3.11 recommended)
 
 Add Space Secrets:
-- `OPENAI_API_KEY` (or `HF_API_KEY`)
-- Optional: `LLM_PROVIDER`, `OPENAI_MODEL`, `HF_MODEL`, `TOP_K`
+- `GROQ_API_KEY` (or `HF_API_KEY`)
+- Optional: `LLM_PROVIDER`, `GROQ_MODEL`, `HF_MODEL`, `TOP_K`
 
 Upload project files (excluding `.env`) and include your knowledge files inside `docs/`.

app/admin/templates/admin.html

@@ -7,7 +7,6 @@
   <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,
@@ -313,23 +312,10 @@
       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 {
@@ -349,6 +335,10 @@
       color: var(--text)
     }
 
+    .export-dropdown:hover .export-menu {
+      display: block
+    }
+
     .search-wrap {
       padding: 12px 16px;
       border-bottom: 1px solid var(--border)
@@ -640,163 +630,6 @@
       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 {
@@ -913,12 +746,18 @@
         </div>
       </div>
       <div class="sidebar-actions">
-        <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 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>
       </div>
       <div class="search-wrap">
         <input type="text" id="search-inp" placeholder="Search sessions…" />
@@ -968,55 +807,6 @@
 
   <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' };
@@ -1321,135 +1111,38 @@
         } catch (e) { showToast('Delete 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);
-        }
-        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'); });
-        });
-      });
-
-      // ── Exports — shared download helper ──────────────────────
+      // ── Exports ───────────────────────────────────────────────
       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`).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`).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');
+        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');
+        }
       }
 
-      $('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();
+      $('btn-export-all-excel').addEventListener('click', () => {
+        downloadExport('/api/admin/export/all?format=excel', 'all_chats_export.xlsx');
       });
 
-      // 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);
-        });
+      $('btn-export-all-json').addEventListener('click', () => {
+        downloadExport('/api/admin/export/all?format=json', 'all_chats_export.json');
       });
 
-      // 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;
-        });
+      $('btn-export-session-excel').addEventListener('click', () => {
+        if (!_activeId) return;
+        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=excel`, `session_${_activeId}.xlsx`);
       });
 
-      // 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';
-        }
+      $('btn-export-session-json').addEventListener('click', () => {
+        if (!_activeId) return;
+        downloadExport(`/api/admin/export/session/${encodeURIComponent(_activeId)}?format=json`, `session_${_activeId}.json`);
       });
 
     })();

app/core/config.py

@@ -31,7 +31,7 @@ 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

app/main.py

@@ -34,9 +34,6 @@ 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,
@@ -176,12 +173,10 @@ async def chat(
         
         error_msg = "⚠️ Oops! Something went wrong."
         if isinstance(e, httpx.HTTPStatusError):
-            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}"
+            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."
                 
         return ChatResponse(reply=error_msg, retrieved_chunks=[])
 

app/services/chunker.py

@@ -1,12 +1,7 @@
 from typing import List, Dict
 
 
-import re
-
 def _tokenize(text: str) -> List[str]:
-    # Replace hyphens with spaces for token counting, but keep the original tokens
-    # This is a simple but effective production approach: split by whitespace 
-    # but ensure we don't count empty strings.
     return text.split()
 
 

app/services/llm.py

@@ -9,99 +9,87 @@ _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 — a highly intelligent, professional HR expert.
-You give precise, concise answers using ONLY the relevant parts of the Expert Data provided.
+SYSTEM_PROMPT = """You are the Martechsol HR Assistant — intelligent, precise, and formal.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-RULE 0 — FILTER THE CONTEXT FIRST
+STEP 1 — UNDERSTAND THE INTENT
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-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.
+Read the question carefully. Identify the SINGLE core topic being asked. Apply intelligent defaults:
+• "timing" / "timings" (no context) → office working hours ONLY — not payment or any other timing
+• "leaves" / "leave" (no context) → leave names + day counts ONLY — NOT leave policies or eligibility
+• "paid leaves" / "all leaves" → enumerate EVERY leave type with its name and count
+• "salary" / "pay" (no context) → salary structure or amount — NOT payment date unless explicitly asked
+• "benefits" / "perks" / "allowances" → list EVERY benefit with its name and value
+• "terminate" / "termination" → resignation/termination procedure — NOT general policies
+If a question has an obvious workplace context, always default to the most common interpretation.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-RULE 1 — ANSWER INTELLIGENTLY (like a real HR expert would)
+STEP 2 — STRICT SCOPE DISCIPLINE
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Understand the user's INTENT and respond accordingly:
-
-• "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.
+Answer ONLY what was asked. NEVER expand into:
+• Policies, approval processes, eligibility rules, or consequences — unless user asks for policy/process
+• Related topics the user did not mention
+• Broad overviews when a specific fact was requested
+• Context that wasn't in the question
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-RULE 2 — FORMAT (use the simplest format that fits)
+STEP 3 — FORMAT DECISION TABLE (MANDATORY — follow exactly)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-■ PARAGRAPH (default — use for most answers):
-  1-3 complete sentences. Bold key values with <b>bold</b>.
-
-■ KEY-VALUE LIST (only for enumerating 4+ items):
-  <b>Item Name:</b> value<br>
-  <b>Item Name:</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>
-
-Do NOT use a list when a paragraph works. Do NOT use <br> inside <li> tags.
+Use this table to pick the format. Do NOT deviate.
+
+  QUESTION TYPE                          → FORMAT TO USE
+  ─────────────────────────────────────────────────────
+  "how many X leaves?"                   → FORMAT A (one number only)
+  "what is X leave?"                     → 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, not a full list)
+
+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.
+
+FORMAT B — EXHAUSTIVE LIST
+  Trigger: ONLY when user says "all leaves", "all benefits", "list all X", "paid leaves", "what leaves".
+  Rule:
+    • Include EVERY single item found — omitting even one is FORBIDDEN
+    • One item per line: <b>Item Name:</b> value<br>
+    • No intro sentence, no closing sentence, no extra commentary
+  Example:
+    <b>Casual Leave:</b> 10 days<br>
+    <b>Sick Leave:</b> 8 days<br>
+    <b>Annual Leave:</b> 14 days<br>
+    <b>Maternity Leave:</b> 90 days<br>
+    <b>Paternity Leave:</b> 3 days<br>
+    <b>Hajj Leave:</b> 30 days<br>
+    ...(list every item — do NOT stop early)
+
+FORMAT C — BRIEF EXPLANATION (procedure / how-to)
+  Trigger: ONLY when user asks "how to apply", "how to get", "what is the process", "how does X work".
+  Rule:
+    • Answer ONLY for the SPECIFIC leave type asked — do NOT list all leaves
+    • Maximum 3 bullet points
+    • Each bullet = one complete, factual sentence. No filler words.
+  Example for "how to get sick leave":
+    • Notify your supervisor or HR within 2 hours of your shift start if absent due to illness.
+    • Submit your leave application immediately upon returning to work.
+    • Provide a medical certificate; failure to do so converts the leave to unpaid.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-RULE 3 — QUALITY
+STRICT QUALITY RULES
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✓ 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
+✓ 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 = 1500) -> str:
@@ -129,15 +117,12 @@ def _build_context(chunks: List[Dict[str, str]], max_words: int = 1500) -> str:
 class LLMService:
     def __init__(
         self,
-        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",
+        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",
@@ -147,9 +132,6 @@ class LLMService:
         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
@@ -197,12 +179,6 @@ Queries:"""
                     "You output only search queries, one per line. No explanations, no numbering.",
                     model_override=self.fireworks_rewrite_model
                 )
-            elif self.provider == "openai":
-                resp = await self._call_openai(
-                    prompt, [],
-                    "You output only search queries, one per line. No explanations, no numbering.",
-                    model_override=self.openai_rewrite_model
-                )
             else:
                 resp = await self._call_groq(
                     prompt, [],
@@ -214,10 +190,9 @@ Queries:"""
                 for q in resp.split("\n")
                 if q.strip() and len(q.strip()) > 3
             ]
-            # Always ensure the original query is the FIRST and prioritized search term
-            if query in queries:
-                queries.remove(query)
-            queries.insert(0, query)
+            # Always include original query
+            if query not in queries:
+                queries.append(query)
             return queries[:3]
         except Exception:
             return [query]
@@ -246,8 +221,6 @@ Queries:"""
 
         if self.provider == "fireworks":
             return await self._call_fireworks(user_prompt, pruned_history, system_msg)
-        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)
 
     async def _call_groq(
@@ -297,8 +270,32 @@ Queries:"""
         data = resp.json()
         content = data["choices"][0]["message"]["content"].strip()
 
-        # ── Post-Processing ──────────────────────────────────────────────────
-        content = _clean_html(content)
+        # ── 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()
+
         return content
 
     async def _call_fireworks(
@@ -352,47 +349,30 @@ Queries:"""
         data = resp.json()
         content = data["choices"][0]["message"]["content"].strip()
 
-        # ── Post-Processing ──────────────────────────────────────────────────
-        content = _clean_html(content)
-        return content
-
-    async def _call_openai(
-        self,
-        user_prompt: str,
-        history: List[Dict[str, str]],
-        system_msg: str,
-        model_override: str = None
-    ) -> str:
-        if not self.openai_api_key:
-            return "Expert access required (OpenAI)."
-
-        url = "https://api.openai.com/v1/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {self.openai_api_key}",
-            "Content-Type": "application/json"
-        }
-
-        messages = [{"role": "system", "content": system_msg}]
-        for msg in history:
-            messages.append({"role": msg["role"], "content": msg["content"]})
-        messages.append({"role": "user", "content": user_prompt})
-
-        target_model = model_override or self.openai_model
-
-        payload = {
-            "model": target_model,
-            "temperature": 0.0,
-            "max_tokens": 512,
-            "messages": messages,
-        }
-
-        resp = await self._client.post(url, headers=headers, json=payload)
-        if resp.status_code >= 400:
-            _log.error("OpenAI API Error %s: %s", resp.status_code, resp.text)
-        resp.raise_for_status()
-        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 (unified) ────────────────
-        content = _clean_html(content)
         return content

app/services/rag_pipeline.py

@@ -1,8 +1,7 @@
 import logging
 import hashlib
-import re
 from collections import OrderedDict
-from typing import Dict, List, Tuple
+from typing import Dict, List
 
 from app.services.llm import LLMService
 from app.services.vector_store import FaissVectorStore
@@ -10,9 +9,10 @@ from app.services.reranker import RerankerService
 
 logger = logging.getLogger(__name__)
 
-# ── Answer cache DISABLED — prompt changes need to take effect immediately ───
-# Re-enable once prompt is finalized by uncommenting the OrderedDict line
-_CACHE_MAX = 0
+# ── 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: OrderedDict = OrderedDict()
 
 
@@ -20,83 +20,84 @@ def _cache_key(message: str) -> 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:
+# ── 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 study unauthorized",
+                       "paid leave types employee entitlement days count"]),
+    ("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", "paid leave maternity employee"]),
+    ("paternity",     ["paternity leave days duration policy", "paid leave paternity employee"]),
+    ("hajj",          ["hajj leave days duration policy", "paid leave hajj religious"]),
+    ("bereavement",   ["bereavement leave death family days", "compassionate leave policy"]),
+    ("sick leave",    ["sick leave days count policy", "medical leave employee entitlement"]),
+    ("casual leave",  ["casual leave days count policy", "leave types employee"]),
+    ("annual leave",  ["annual leave days count policy", "leave entitlement per year"]),
+    ("study leave",   ["study leave education policy days", "employee study leave entitlement"]),
+    ("leave",         ["casual leave sick leave annual leave maternity paternity hajj bereavement study unauthorized",
+                       "leave types employee entitlement days"]),
+    # ── 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 shift hours"]),
+    ("schedule",      ["office working hours schedule", "workday start end time"]),
+    # ── Salary / Pay ──
+    ("salary",        ["salary structure payroll compensation amount", "monthly pay increment deduction"]),
+    ("pay",           ["salary structure payroll compensation", "payment date schedule"]),
+    ("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"]),
+    # ── 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"]),
+    ("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]:
     """
-    Expands compound words like 'pro-rata' to all their variants.
-    Runs in microseconds — no network call required.
+    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.
     """
-    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
-
+    msg_lower = message.lower()
+    queries: List[str] = [message]  # Original query always first
 
-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()
+    for keyword, variants in _INTENT_MAP:
+        if keyword in msg_lower:
+            for v in variants:
+                if v not in queries:
+                    queries.append(v)
+            break  # Only apply first (most specific) matching intent
 
-
-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
+    return queries[:3]  # Cap at 3, consistent with previous LLM behaviour
 
 
 # RRF scores are small (e.g. 0.016–0.033), so threshold must be very low
-RELEVANCE_THRESHOLD = 0.001
+RELEVANCE_THRESHOLD = 0.01
 # Cross-encoder logit > 0 means > 50% relevance probability
 RERANK_THRESHOLD = 0.0
 # If ALL chunks fail rerank threshold, fall back to this many top chunks
@@ -122,67 +123,81 @@ 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)
+            _answer_cache.move_to_end(key)  # Mark as recently used
             logger.info("Cache HIT for: '%s'", message[:40])
             return _answer_cache[key]
 
-        # ── 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 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 2: Batched hybrid search ──
-        all_retrieved = self.vector_store.multi_search(queries, top_k=self.top_k)
+        # ── 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 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 for: '%s' — returning no-info response", message)
+            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"
             reply = await self.llm_service.answer(
-                question=llm_question,
+                question=message,
                 chunks=[],
                 history=history,
                 user_name=user_name
             )
             return {"reply": reply, "retrieved_chunks": []}
 
-        # ── Step 4: Cross-Encoder Reranking ──
-        rerank_query = llm_question  # Use the enriched question for better reranking
+        # ── 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]}"
+
         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: don't say "no info" when chunks were retrieved
+        # ── 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)
         if not final_chunks and reranked_chunks:
             final_chunks = reranked_chunks[:RERANK_FALLBACK_N]
             logger.info(
-                "Rerank fallback — all below threshold (best=%.3f), using top %d",
-                reranked_chunks[0].get("rerank_score", 0), len(final_chunks)
+                "Rerank fallback activated — all chunks below threshold (best score=%.3f), using top %d",
+                reranked_chunks[0].get("rerank_score", 0),
+                len(final_chunks)
             )
 
         logger.info(
-            "Pipeline: retrieved=%d → filtered=%d → reranked=%d → final=%d (best=%.3f)",
+            "Pipeline: retrieved=%d → relevance_filtered=%d → reranked=%d → final=%d (best_score=%.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 ──
+        # ── Step 5: Generate answer with top-ranked context ──
         reply = await self.llm_service.answer(
-            question=llm_question,
+            question=message,
             chunks=final_chunks,
             history=history,
             user_name=user_name
         )
         result = {"reply": reply, "retrieved_chunks": final_chunks}
 
-        # ── Populate LRU cache ──
+        # ── Populate cache (evict oldest if at capacity) ──
         _answer_cache[key] = result
         if len(_answer_cache) > _CACHE_MAX:
-            _answer_cache.popitem(last=False)
-        logger.info("Stored answer for: '%s'", message[:40])
+            _answer_cache.popitem(last=False)  # Remove least-recently-used
+        logger.info("Cache MISS — stored answer for: '%s'", message[:40])
 
         return result

app/services/vector_store.py

@@ -11,26 +11,6 @@ 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:
@@ -61,8 +41,7 @@ class FaissVectorStore:
 
     def _compute_docs_fingerprint(self) -> str:
         hasher = hashlib.sha256()
-        # 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
+        # Include chunk settings in fingerprint so changing them triggers re-index
         hasher.update(str(self.chunk_size_tokens).encode("utf-8"))
         hasher.update(str(self.chunk_overlap_tokens).encode("utf-8"))
         
@@ -110,7 +89,7 @@ class FaissVectorStore:
         index = faiss.IndexFlatIP(dim)
         index.add(vectors)
 
-        tokenized_corpus = [_analyze(c["text"]) for c in chunks]
+        tokenized_corpus = [c["text"].lower().split() for c in chunks]
         bm25 = BM25Okapi(tokenized_corpus)
 
         self.index = index
@@ -128,76 +107,54 @@ class FaissVectorStore:
         )
 
     def search(self, query: str, top_k: int = 4) -> List[Dict[str, str]]:
-        """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:
+        if self.index is None or not self.metadata or self.bm25 is None:
             self.last_retrieved = []
             return []
 
-        # 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)
+        # 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)
         
-        # 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
-        )
+        # Get top indices for BM25
+        bm25_top_indices = np.argsort(bm25_scores)[::-1][:top_k * 2]
 
-        # 3. Batched BM25 Search
-        # Combine all tokenized queries
+        # Combine using Reciprocal Rank Fusion (RRF)
+        # RRF_score = 1 / (k + rank)
         k = 60
         rrf_scores = {}
-
-        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))
-            
-            # 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]
+        
+        # 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 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))
+        # 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))
 
-        # 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]
+        # Sort by combined RRF score
+        sorted_indices = sorted(rrf_scores.keys(), key=lambda x: rrf_scores[x], reverse=True)[:top_k]
 
         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]),
+                    "score": float(rrf_scores[idx]), # RRF score
                 }
             )
-        
         self.last_retrieved = results
         return results
 

app/ui_gradio.py

@@ -34,17 +34,11 @@ 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,
     hf_api_key=settings.hf_api_key,
     hf_model=settings.hf_model,
-    fireworks_api_key=settings.fireworks_api_key,
-    fireworks_model=settings.fireworks_model,
-    fireworks_rewrite_model=settings.fireworks_rewrite_model,
     timeout_s=settings.request_timeout_s,
 )
 reranker_service = RerankerService(settings.reranker_model)
@@ -126,12 +120,8 @@ async def chat_fn(message: str, chat_history: List[Dict[str, str]], session_id:
         reply = await _get_reply(message, original_history)
     except httpx.HTTPStatusError as e:
         logger.error(f"HTTP Error: {e.response.status_code} - {e.response.text}")
-        try:
-            error_data = e.response.json()
-            api_msg = error_data.get("error", {}).get("message", e.response.text)
-        except Exception:
-            api_msg = e.response.text
-        reply = f"⚠️ API Error ({e.response.status_code}): {api_msg}"
+        reply = "⚠️ Rate limit reached. Please slow down a bit!" if e.response.status_code == 429 \
+            else "⚠️ I encountered an error. Please try again in a few seconds."
     except Exception as e:
         logger.error(f"Unexpected error: {str(e)}\n{traceback.format_exc()}")
         reply = f"⚠️ Oops! Something went wrong."
@@ -219,45 +209,7 @@ custom_css = """
     border: none !important;
 }
 
-/* Remove top spacing before the first element in every chat bubble. */
-.message > *:first-child,
-.message p:first-child,
-.message ul:first-child,
-.message ol:first-child,
-.prose > p:first-child,
-.prose > ul:first-child,
-.prose > ol:first-child,
-.prose > *:first-child,
-.md p:first-child,
-.md > *:first-child,
-.md ul:first-child,
-.bubble-wrap > *:first-child,
-.bubble-wrap p:first-child,
-[data-testid="bot"] p:first-child,
-[data-testid="bot"] > div > *:first-child,
-.bot p:first-child,
-.bot > div > *:first-child,
-.svelte-1s78gfg p:first-child {
-    margin-top: 0 !important;
-    padding-top: 0 !important;
-}
-
-/* ── Fix ul/li spacing inside chat bubbles ── */
-.message ul, .prose ul, .md ul, .bot ul,
-[data-testid="bot"] ul {
-    margin: 0 !important;
-    padding-left: 1.2em !important;
-    padding-top: 0 !important;
-    padding-bottom: 0 !important;
-}
-.message li, .prose li, .md li, .bot li,
-[data-testid="bot"] li {
-    margin: 2px 0 !important;
-    padding: 0 !important;
-    line-height: 1.5 !important;
-}
-
-/* Aggressively hide the footer */
+/* Aggressively hide the footer, including HF injected footers if inside the container */
 footer, .footer, footer * {
     display: none !important;
     visibility: hidden !important;
@@ -267,9 +219,8 @@ footer, .footer, footer * {
 }
 """
 
-# JS: runs immediately on page load — generates/loads session_id from localStorage.
-# Also injects a MutationObserver to eliminate the top-spacing Gradio adds inside
-# each chat bubble, regardless of internal class names.
+# JS: runs immediately on page load — generates/loads session_id from localStorage
+# and restores previous chat history. Completely non-blocking.
 _SESSION_JS = """
 async () => {
     // ── Session ID: generate once, persist forever in localStorage ──
@@ -281,29 +232,6 @@ async () => {
     // Write the session_id into the hidden Gradio textbox
     const el = document.getElementById('session-id-box')?.querySelector('textarea');
     if (el) { el.value = sid; el.dispatchEvent(new Event('input', {bubbles:true})); }
-
-    // ── Fix top spacing inside chat bubbles ──────────────────────────
-    // Gradio wraps message content in a <p> or block element with margin-top.
-    // We walk every rendered message and zero the first child's top margin/padding.
-    function fixBubbleSpacing() {
-        // Select all rendered message rows inside the chatbot
-        const chatbot = document.getElementById('chatbot-window');
-        if (!chatbot) return;
-        chatbot.querySelectorAll('div, article, section').forEach(el => {
-            const first = el.firstElementChild;
-            if (first && (first.tagName === 'P' || first.tagName === 'UL' || first.tagName === 'OL' || first.tagName === 'B')) {
-                first.style.setProperty('margin-top', '0', 'important');
-                first.style.setProperty('padding-top', '0', 'important');
-            }
-        });
-    }
-
-    // Run once immediately, then watch for new messages
-    fixBubbleSpacing();
-    const observer = new MutationObserver(fixBubbleSpacing);
-    const target = document.getElementById('chatbot-window') || document.body;
-    observer.observe(target, { childList: true, subtree: true });
-
     return sid;
 }
 """