Refine RAG pipeline for comprehensive leave retrieval, improve system prompt, and fix Gradio HTML rendering

.gitignore

@@ -4,4 +4,6 @@ __pycache__/
 .mypy_cache/
 .venv/
 venv/
-# No longer ignoring docs or index for this full backup push
+# Ignoring data directory to prevent pushing binary index files
+data/index/
+data/sessions/

app/core/config.py

@@ -31,7 +31,7 @@ class Settings(BaseSettings):
     chunk_size_tokens: int = 350  # Reduced for TPM safety
     chunk_overlap_tokens: int = 80
     top_k: int = Field(default=20, alias="TOP_K")  
-    max_context_chunks: int = 5  # Reduced to 5 to stay within 6000 TPM limit
+    max_context_chunks: int = 10  # Increased to 10 to ensure all list items (like leaves) are captured
     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/services/llm.py

@@ -8,38 +8,76 @@ import re
 # ═══════════════════════════════════════════════════════════════════════
 SYSTEM_PROMPT = """You are the Martechsol HR Assistant — intelligent, precise, and formal.
 
-INTELLIGENCE PROTOCOL (follow in order):
-
-1. UNDERSTAND INTENT FIRST
-   Identify exactly what the user is asking. Apply workplace common sense:
-   • "timing" or "timings" → office working hours (not salary schedule)
-   • "leaves" or "paid leaves" → list ALL leave types with name + count
-   • Always choose the most natural, day-to-day workplace interpretation.
-
-2. SCOPE DISCIPLINE — Answer ONLY what was asked.
-   • Never mention policies, procedures, approval processes, or consequences unless user explicitly asks.
-   • "How many leaves?" = names + counts only. Nothing more.
-   • "What are timings?" = office hours only. Nothing more.
-
-3. COMPLETE LISTING — When user asks for a category (leaves, benefits, allowances):
-   List EVERY item with its key detail (name + number) — one per line.
-
-4. WORD ECONOMY — Keep responses ≤35 words. Always write complete, grammatically correct sentences. Never cut a sentence mid-way.
-
-5. ZERO HALLUCINATION — Every fact must come from Expert Data only.
-   If the information is not available, say exactly: "I don't have that information."
-
-6. SOURCE SILENCE — NEVER say "document", "handbook", "manual", "policy", "data", or reference any source. Just answer directly and naturally.
-
-HTML FORMATTING RULES:
-• Use <b>bold</b> for all key terms, names, numbers, and dates
-• Use <br> to separate each item or point
-• No long paragraphs — one clean line per point
-
-TONE: Formal, warm, and professional."""
-
-
-def _build_context(chunks: List[Dict[str, str]], max_words: int = 1000) -> str:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STEP 1 — UNDERSTAND THE INTENT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+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.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STEP 2 — STRICT SCOPE DISCIPLINE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+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
+
+Scope examples:
+  "How many sick leaves?" → ONE number. Not the sick leave policy.
+  "What are office timings?" → ONE sentence with time range. Not break times or exceptions.
+  "What are paid leaves?" → Complete list of all paid leave types + counts. Not rules for taking them.
+  "Tell me about maternity leave" → Count + brief key fact. Not full policies unless asked.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STEP 3 — CHOOSE THE RIGHT FORMAT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+FORMAT A — SINGLE FACT (default for most questions)
+  When: One direct answer needed (timings, a specific leave count, a single number/date)
+  Rule: ONE complete sentence. Maximum 25–30 words. Never cut mid-sentence.
+  Example: Office hours are <b>9:00 AM to 6:00 PM</b>, Monday to Saturday.
+
+FORMAT B — EXHAUSTIVE LIST
+  When: User asks for ALL items in a category ("all leaves", "all benefits", "list all X", "paid 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
+    • Continue until ALL items are listed
+  Example:
+    <b>Casual Leave:</b> 10 days<br>
+    <b>Sick Leave:</b> 10 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
+  When: User asks HOW something works, or asks for a process/procedure
+  Rule: Maximum 3 bullet points. Each bullet = one complete, factual sentence. No filler words.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STRICT QUALITY RULES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✓ 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:
     """Combines retrieved chunks into a clean context string, capped at max_words.
     Prevents TPM spikes when chunks are unexpectedly large."""
     if not chunks:
@@ -82,15 +120,25 @@ class LLMService:
 
     async def generate_multi_queries(self, query: str, history: List[Dict[str, str]]) -> List[str]:
         """Generates multiple search queries to capture broader context from the document."""
-        prompt = f"""You are an HR search optimizer for a company employee handbook. The user asked: "{query}"
-
-Generate 3 search queries to find ALL relevant information. Priorities:
-- For "timing/timings" → Query 1 MUST focus on office hours/working hours/workday schedule
-- For "leaves/leave/paid leaves" → Cover ALL types: casual leave, sick leave, annual leave, maternity leave, paternity leave, hajj leave, study leave
-- For "salary/pay/compensation" → Cover salary structure, payroll, increments, deductions
-- Use HR synonyms and related terminology
-
-Output ONLY 3 queries, one per line. No numbers, no bullets, no extra text.
+        prompt = f"""You are an intelligent HR search optimizer. A user asked: "{query}"
+
+STEP 1 — UNDERSTAND THE INTENT:
+What is the user ACTUALLY asking about? Apply workplace common sense:
+- "timing" / "timings" (no qualifier) = office working hours, workday schedule
+- "leaves" / "paid leaves" / "all leaves" = all leave types available to employees
+- "salary" / "pay" = salary structure or amount
+- "benefits" / "allowances" = employee benefits and perks
+- "terminate" / "resign" = termination or resignation process
+
+STEP 2 — GENERATE 3 TARGETED SEARCH QUERIES:
+Write 3 diverse search queries to retrieve ALL relevant information from an employee handbook.
+For the identified intent, cover synonyms, related terms, and sub-categories:
+- For office timings → search: working hours, office schedule, workday timing, shift hours
+- For leaves → cover ALL types: casual leave, sick leave, annual leave, maternity leave, paternity leave, hajj leave, study leave, earned leave, bereavement leave, unauthorized leave
+- For salary → cover: salary structure, payroll, compensation, increments, deductions
+- For benefits → cover: allowances, perks, medical, bonuses, reimbursements
+
+Output ONLY 3 queries, one per line. No numbers, no bullets, no explanations.
 
 Queries:"""
 

app/ui_gradio.py

@@ -126,71 +126,66 @@ async def chat_fn(message: str, chat_history: List[Dict[str, str]], session_id:
         logger.error(f"Unexpected error: {str(e)}\n{traceback.format_exc()}")
         reply = f"⚠️ Oops! Something went wrong."
 
-    # ── Humanistic letter-by-letter typing with occasional typos ──────
-    displayed = ""
-    
-    # We'll process word by word to decide on typos, but type letter by letter
-    words = reply.split(" ")
-    for i, word in enumerate(words):
-        separator = " " if i > 0 else ""
-        
-        # Decide if this word gets a typo
+    # ── Humanistic letter-by-letter typing — HTML-safe ────────────────────
+    displayed = ""       # what is shown in the chat bubble
+    buffer = ""          # invisible accumulator for mid-HTML-tag characters
+    in_tag = False       # True while we are inside a < … > sequence
+
+    for char in reply:
+        if char == '<':
+            in_tag = True
+            buffer += char
+            continue
+
+        if in_tag:
+            buffer += char
+            if char == '>':
+                # Tag is now complete — flush it to the display all at once
+                in_tag = False
+                displayed += buffer
+                buffer = ""
+                chat_history[-1] = {"role": "assistant", "content": displayed}
+                yield gr.update(value="", interactive=False), chat_history
+                # Small pause after a <br> to mimic line-break pacing
+                if displayed.endswith('<br>') or displayed.endswith('<br/>'):
+                    await asyncio.sleep(random.uniform(0.1, 0.2))
+            continue
+
+        # ── Normal character (not inside a tag) ───────────────────────────
+        # Decide typo chance only for plain alphabetic words
         do_typo = (
-            i > 0 
-            and len(word) > 4 
-            and random.random() < TYPO_CHANCE 
-            and word.isalpha()
+            char.isalpha()
+            and len(displayed) > 8           # skip the very beginning
+            and random.random() < TYPO_CHANCE
         )
 
         if do_typo:
-            # Pick a random position to make a mistake
-            typo_pos = random.randint(2, len(word) - 1)
-            
-            # 1. Type the word correctly up to the typo position
-            for char in (separator + word[:typo_pos]):
-                displayed += char
-                chat_history[-1] = {"role": "assistant", "content": displayed}
-                yield gr.update(value="", interactive=False), chat_history
-                await asyncio.sleep(random.uniform(0.03, 0.07))
-            
-            # 2. Type the wrong character
-            wrong_char = _nearby_char(word[typo_pos])
+            wrong_char = _nearby_char(char)
             displayed += wrong_char
             chat_history[-1] = {"role": "assistant", "content": displayed}
             yield gr.update(value="", interactive=False), chat_history
-            await asyncio.sleep(random.uniform(0.15, 0.3)) # Pause after error
-            
-            # 3. Realize and Backspace
-            await asyncio.sleep(random.uniform(0.2, 0.4))
+            await asyncio.sleep(random.uniform(0.15, 0.3))
+
+            # Backspace the wrong character
             displayed = displayed[:-1]
             chat_history[-1] = {"role": "assistant", "content": displayed}
             yield gr.update(value="", interactive=False), chat_history
             await asyncio.sleep(random.uniform(0.1, 0.2))
-            
-            # 4. Type the correct character and the rest of the word
-            for char in word[typo_pos:]:
-                displayed += char
-                chat_history[-1] = {"role": "assistant", "content": displayed}
-                yield gr.update(value="", interactive=False), chat_history
-                await asyncio.sleep(random.uniform(0.04, 0.08))
+
+        # Type the correct character
+        displayed += char
+        chat_history[-1] = {"role": "assistant", "content": displayed}
+        yield gr.update(value="", interactive=False), chat_history
+
+        # Pacing: punctuation pauses, space micro-pause, normal char speed
+        if char in '.!?':
+            await asyncio.sleep(random.uniform(0.35, 0.7))
+        elif char in ',:;':
+            await asyncio.sleep(random.uniform(0.15, 0.3))
+        elif char == ' ':
+            await asyncio.sleep(random.uniform(0.06, 0.13))
         else:
-            # Type the whole word (including separator) letter by letter
-            for char in (separator + word):
-                displayed += char
-                chat_history[-1] = {"role": "assistant", "content": displayed}
-                yield gr.update(value="", interactive=False), chat_history
-                
-                # Faster typing for letters, slight pause for space
-                if char == " ":
-                    await asyncio.sleep(random.uniform(0.08, 0.15))
-                else:
-                    await asyncio.sleep(random.uniform(0.02, 0.06))
-
-        # Punctuation pauses (at the end of words)
-        if word and word[-1] in ".!?":
-            await asyncio.sleep(random.uniform(0.4, 0.8))
-        elif word and word[-1] in ",:;":
-            await asyncio.sleep(random.uniform(0.2, 0.4))
+            await asyncio.sleep(random.uniform(0.02, 0.06))
 
     # ── Fire-and-forget: persist to session store (never blocks the UI) ───
     # We only save successful responses, not error messages
@@ -245,8 +240,12 @@ with gr.Blocks(title="Martechsol Assistant", theme=gr.themes.Soft(), css=custom_
     gr.Markdown("# Martechsol Assistant")
     gr.Markdown("Welcome! How can I help you today?")
     
-    chatbot = gr.Chatbot(show_label=False, elem_id="chatbot-window")
-    
+    chatbot = gr.Chatbot(
+        show_label=False,
+        elem_id="chatbot-window",
+        type="messages",
+        render_markdown=True,
+    )
     with gr.Row():
         msg = gr.Textbox(
             placeholder="Type your question here...",

get_models.py

@@ -0,0 +1,25 @@
+import asyncio
+import os
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+async def main():
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        print("No API Key")
+        return
+    url = "https://api.groq.com/openai/v1/models"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(url, headers=headers)
+        if resp.status_code == 200:
+            models = resp.json().get("data", [])
+            for m in models:
+                if "deepseek" in m["id"].lower() or "qwen" in m["id"].lower():
+                    print(m["id"])
+        else:
+            print(resp.status_code, resp.text)
+
+asyncio.run(main())

test_groq.py

@@ -0,0 +1,26 @@
+import asyncio
+import os
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+async def main():
+    api_key = os.getenv("GROQ_API_KEY")
+    url = "https://api.groq.com/openai/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "model": "deepseek-r1-distill-llama-70b",
+        "temperature": 0.0,
+        "max_tokens": 1200,
+        "messages": [{"role": "system", "content": "hello"}, {"role": "user", "content": "test"}]
+    }
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(url, headers=headers, json=payload)
+        print(resp.status_code)
+        print(resp.text)
+
+asyncio.run(main())