Update app.py

app.py

@@ -1,98 +1,115 @@
 import os
-import gradio as gr
-import pdfplumber
 import re
-
+import pdfplumber
+import gradio as gr
 from langchain.docstore.document import Document
-from langchain_community.vectorstores import FAISS  # ✅ Fixed deprecation warning
+from langchain_community.vectorstores import FAISS          # new import path
 from langchain.embeddings.base import Embeddings
 from sklearn.feature_extraction.text import TfidfVectorizer
-from langchain.chains import RetrievalQA
 from langchain.prompts import PromptTemplate
+from langchain.chains import RetrievalQA
 from langchain_openai import ChatOpenAI
 from transformers import pipeline
 
-
-# Set OpenRouter API env vars (used by ChatOpenAI)
-os.environ["OPENAI_API_KEY"] = os.environ.get("OPENROUTER_API_KEY")
+# ------------------------------------------------------------------
+# 🔧 1.  OpenRouter configuration (acts as an OpenAI‑compatible host)
+# ------------------------------------------------------------------
+os.environ["OPENAI_API_KEY"]  = os.getenv("OPENROUTER_API_KEY")  # use the same key
 os.environ["OPENAI_API_BASE"] = "https://openrouter.ai/api/v1"
-os.environ["OPENAI_API_HEADERS"] = '{"HTTP-Referer":"https://huggingface.co", "X-Title":"PDF-RAG"}'
-
-# Global variables
-qa_chain = None
-translator_en2ur = None
-translator_ur2en = None
-
-# -------------------- PDF Extraction --------------------
-def extract_clean_sections(file_path):
+os.environ["OPENAI_API_HEADERS"] = (
+    '{"HTTP-Referer":"https://huggingface.co", "X-Title":"PDF‑RAG"}'
+)
+
+# ------------------------------------------------------------------
+# 📄 2.  PDF → clean sections
+# ------------------------------------------------------------------
+def extract_clean_sections(file_path: str):
     with pdfplumber.open(file_path) as pdf:
-        full_text = ""
+        full = ""
         for page in pdf.pages:
-            text = page.extract_text()
-            if text:
-                text = re.sub(r'Systems Campus.*?Lahore', '', text)
-                text = re.sub(r'E-mail:.*?systemsltd\.com', '', text)
-                full_text += text + "\n"
+            text = page.extract_text() or ""
+            # strip repeating footer/header noise
+            text = re.sub(r"Systems Campus.*?Lahore", "", text, flags=re.I)
+            text = re.sub(r"E-mail:.*?systemsltd\.com", "", text, flags=re.I)
+            full += text + "\n"
 
+    # split on headings in ALL‑CAPS followed by colon
     pattern = r"(?<=\n)([A-Z][^\n]{3,50}):"
-    parts = re.split(pattern, full_text)
+    parts = re.split(pattern, full)
 
     docs = []
     for i in range(1, len(parts), 2):
-        title = parts[i].strip()
+        title   = parts[i].strip()
         content = parts[i + 1].strip()
         if len(content) > 20:
-            docs.append(Document(page_content=f"{title}:\n{content}", metadata={"section": title}))
+            docs.append(
+                Document(page_content=f"{title}:\n{content}", metadata={"section": title})
+            )
     return docs
 
-# -------------------- TF-IDF Embedder --------------------
+# ------------------------------------------------------------------
+# 🔍 3.  Lightweight TF‑IDF embeddings (LangChain interface)
+# ------------------------------------------------------------------
 class TfidfEmbedding(Embeddings):
     def __init__(self):
-        self.vectorizer = TfidfVectorizer()
+        self.vec = TfidfVectorizer()
 
     def fit(self, texts):
-        self.vectorizer.fit(texts)
+        self.vec.fit(texts)
 
     def embed_documents(self, texts):
-        return self.vectorizer.transform(texts).toarray()
+        return self.vec.transform(texts).toarray()
 
     def embed_query(self, text):
-        return self.vectorizer.transform([text]).toarray()[0]
+        return self.vec.transform([text]).toarray()[0]
 
-# -------------------- Custom Prompt --------------------
-TEMPLATE = """
-You are a strict healthcare policy checker for Systems Ltd.
+# ------------------------------------------------------------------
+# 📝 4.  Strict answer prompt
+# ------------------------------------------------------------------
+PROMPT_TMPL = """
+You are a strict healthcare policy checker for Systems Ltd.
 Always begin your answer clearly:
 - Say "Yes, ..." if the claim is valid
 - Say "No, ..." if the claim is not valid
-- Say "Partially, ..." if it's conditionally allowed
-Use the following policy information to support your answer.
+- Say "Partially, ..." if it is conditionally allowed
+Use ONLY the following policy information to justify your answer.
 {context}
+
 Question: {question}
+
 Answer:
 """
-custom_prompt = PromptTemplate(template=TEMPLATE, input_variables=["context", "question"])
+STRICT_PROMPT = PromptTemplate(
+    template=PROMPT_TMPL, input_variables=["context", "question"]
+)
+
+# globals
+qa_chain = None
+tr_en2ur = None
+tr_ur2en = None
 
-# -------------------- Policy Initialization --------------------
-def initialize_policy():
-    global qa_chain, translator_en2ur, translator_ur2en
+# ------------------------------------------------------------------
+# 🚀 5.  Initialise on startup (build index + load translators)
+# ------------------------------------------------------------------
+def initialise():
+    global qa_chain, tr_en2ur, tr_ur2en
 
-    docs = extract_clean_sections("healthcare_policy.pdf")
-    texts = [doc.page_content for doc in docs]
+    docs   = extract_clean_sections("healthcare_policy.pdf")
+    texts  = [d.page_content for d in docs]
 
-    embedder = TfidfEmbedding()
-    embedder.fit(texts)
+    emb    = TfidfEmbedding()
+    emb.fit(texts)
 
-    vectordb = FAISS.from_texts(texts, embedder)
-    retriever = vectordb.as_retriever()
+    vectdb   = FAISS.from_texts(texts, emb)
+    retr     = vectdb.as_retriever()
 
     llm = ChatOpenAI(
-        model="tngtech/deepseek-r1t2-chimera:free",
+        model="tngtech/deepseek-r1t2-chimera:free",      # any OpenRouter model OK
         base_url="https://openrouter.ai/api/v1",
         api_key=os.getenv("OPENAI_API_KEY"),
         default_headers={
             "HTTP-Referer": "https://huggingface.co",
-            "X-Title": "PDF-RAG"
+            "X-Title": "PDF‑RAG"
         },
         temperature=0.0
     )
@@ -100,53 +117,69 @@ def initialize_policy():
     qa_chain = RetrievalQA.from_chain_type(
         llm=llm,
         chain_type="stuff",
-        retriever=retriever,
+        retriever=retr,
         return_source_documents=False,
-        chain_type_kwargs={"prompt": custom_prompt}
+        chain_type_kwargs={"prompt": STRICT_PROMPT},
     )
 
-    # ✅ Load translation models
-    translator_en2ur = pipeline("translation", model="Helsinki-NLP/opus-mt-en-ur")
-    translator_ur2en = pipeline("translation", model="Helsinki-NLP/opus-mt-ur-en")
+    # translation pipelines (require `sentencepiece`)
+    tr_en2ur = pipeline("translation", model="Helsinki-NLP/opus-mt-en-ur")
+    tr_ur2en = pipeline("translation", model="Helsinki-NLP/opus-mt-ur-en")
 
+# ------------------------------------------------------------------
+# 🗣️ 6.  Translation helpers
+# ------------------------------------------------------------------
+def urdu_to_english(text: str) -> str:
+    return tr_ur2en(text)[0]["translation_text"]
 
-# -------------------- QA with Bilingual Support --------------------
-def ask_policy_question(question, language):
+def english_to_urdu(text: str) -> str:
+    return tr_en2ur(text)[0]["translation_text"]
+
+# ------------------------------------------------------------------
+# 🤖 7.  Main QA endpoint
+# ------------------------------------------------------------------
+def answer(question: str, lang: str):
     if qa_chain is None:
-        return "The policy is still loading. Please wait."
+        return "⏳ Policy is still loading, please wait..."
+
     try:
-        if language == "Urdu":
-            question_en = translator_ur2en(question)[0]['translation_text']
-            answer_en = qa_chain.run(question_en)
-            answer_ur = translator_en2ur(answer_en)[0]['translation_text']
-            return answer_ur
-        else:
-            return qa_chain.run(question)
+        # 🔄 Urdu → English → RAG
+        q_en = urdu_to_english(question) if lang == "Urdu" else question
+        a_en = qa_chain.run(q_en)
+
+        # 🔄 English → Urdu (if needed)
+        return english_to_urdu(a_en) if lang == "Urdu" else a_en
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {e}"
 
-# -------------------- Gradio Interface --------------------
-status_text = "Loading..."
+# ------------------------------------------------------------------
+# 🎛️ 8.  Gradio UI
+# ------------------------------------------------------------------
+status = "⏳ Loading policy ..."
 
 with gr.Blocks() as demo:
-    gr.Markdown("## 📋 SL HealthCare Claim Checker (Bilingual: English / اردو)")
+    gr.Markdown("## 📋 SL HealthCare Claim Checker — Bilingual (English / اردو)")
 
-    status_box = gr.Textbox(label="Status", value=status_text, interactive=False)
+    status_box = gr.Textbox(value=status, label="Status", interactive=False)
 
     with gr.Row():
-        language = gr.Radio(choices=["English", "Urdu"], label="Select Language / زبان منتخب کریں", value="English")
-        question = gr.Textbox(label="Enter your claim question / اپنا سوال درج کریں")
-        ask_btn = gr.Button("Ask / پوچھیں")
+        lang_sel  = gr.Radio(choices=["English", "Urdu"], value="English",
+                             label="Language / زبان")
+        question  = gr.Textbox(lines=2, label="Your question / اپنا سوال")
+        ask_btn   = gr.Button("Ask / پوچھیں")
+
+    answer_box = gr.Textbox(lines=6, label="Answer / جواب", interactive=False)
 
-    answer = gr.Textbox(label="Answer / جواب", lines=6)
-    ask_btn.click(fn=ask_policy_question, inputs=[question, language], outputs=answer)
+    ask_btn.click(answer, inputs=[question, lang_sel], outputs=answer_box)
 
-    def startup():
-        global status_text
-        initialize_policy()
-        status_text = "Policy loaded. You may now ask questions."
-        return status_text
+    def on_load():
+        global status
+        initialise()
+        status = "✅ Policy loaded — ask away!"
+        return status
 
-    demo.load(fn=startup, outputs=status_box)
+    demo.load(fn=on_load, outputs=status_box)
 
-demo.launch()
+# local run
+if __name__ == "__main__":
+    demo.launch()