commit

app.py

@@ -1,64 +1,111 @@
+import os
+os.environ["OTEL_TRACES_EXPORTER"] = "none"
+
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+import uuid
+from utils.chat import ChatLaborLaw
+
+
+# Function to initialize a new session and create chatbot instance for that session
+async def initialize_session():
+    session_id = str(uuid.uuid4())[:8]
+    chatbot = ChatLaborLaw()
+    # chatbot = Chat("gemini-2.0-flash")
+    history = []
+    return "", session_id, chatbot, history
+
+
+# Function to handle user input and chatbot response
+async def chat_function(prompt, history, session_id, chatbot):
+    if chatbot is None:
+        return history, "", session_id, chatbot # Skip if chatbot not ready
+    
+    # Append the user's input to the message history
+    history.append({"role": "user", "content": prompt})
+
+    # Get the response from the chatbot
+    response = await chatbot.chat(prompt)  # ใช้ await ได้แล้ว
+    
+    # Append the assistant's response to the message history
+    history.append({"role": "assistant", "content": response})
+    
+    return history, "", session_id, chatbot
+
+
+# Function to save feedback with chat history
+async def send_feedback(feedback, history, session_id, chatbot):
+    os.makedirs("app/feedback", exist_ok=True)
+    filename = f"app/feedback/feedback_{session_id}.txt"
+    with open(filename, "a", encoding="utf-8") as f:
+        f.write("=== Feedback Received ===\n")
+        f.write(f"Session ID: {session_id}\n")
+        f.write(f"Feedback: {feedback}\n")
+        f.write("Chat History:\n")
+        for msg in history:
+            f.write(f"{msg['role']}: {msg['content']}\n")
+        f.write("\n--------------------------\n\n")
+    return "" # Clear feedback input
+
+
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="amber")) as demo:
+    gr.Markdown("# สอบถามเรื่องกฎหมายแรงงาน")
+
+    # Initialize State
+    session_state = gr.State()
+    chatbot_instance = gr.State()
+    chatbot_history = gr.State([])
+
+    # Chat UI
+    chatbot_interface = gr.Chatbot(type="messages", label="Chat History")
+    user_input = gr.Textbox(placeholder="Type your message here...", elem_id="user_input", lines=1)
+
+    submit_button = gr.Button("Send")
+    clear_button = gr.Button("Delete Chat History")
+
+    # Submit actions
+    submit_button.click(
+        fn=chat_function,
+        inputs=[user_input, chatbot_history, session_state, chatbot_instance],
+        outputs=[chatbot_interface, user_input, session_state, chatbot_instance]
+    )
+
+    user_input.submit(
+        fn=chat_function,
+        inputs=[user_input, chatbot_history, session_state, chatbot_instance],
+        outputs=[chatbot_interface, user_input, session_state, chatbot_instance]
+    )
+
+    # # Clear history
+    # clear_button.click(lambda: [], outputs=chatbot_interface)
+    clear_button.click(
+        fn=initialize_session,
+        inputs=[],
+        outputs=[user_input, session_state, chatbot_instance, chatbot_history]
+    ).then(
+        fn=lambda: gr.update(value=[]),
+        inputs=[],
+        outputs=chatbot_interface
+    )
+
+
+    # Feedback section
+    with gr.Row():
+        feedback_input = gr.Textbox(placeholder="Send us feedback...", label="Feedback")
+        send_feedback_button = gr.Button("Send Feedback")
+
+    send_feedback_button.click(
+        fn=send_feedback,
+        inputs=[feedback_input, chatbot_history, session_state, chatbot_instance],
+        outputs=[feedback_input]
+    )
+
+    # Initialize session on load
+    demo.load(
+        fn=initialize_session,
+        inputs=[],
+        outputs=[user_input, session_state, chatbot_instance, chatbot_history]
+    )
+
+# Launch
+demo.launch(share=True)

requirements.txt

@@ -1 +1,26 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+langchain==0.3.26
+langchain-community==0.3.26
+langchain-core==0.3.66
+langchain-google-genai==2.1.6
+langchain-huggingface==0.3.0
+langchain-mongodb==0.6.2
+langchain-openai==0.3.27
+langchain-text-splitters==0.3.8
+langfuse==3.1.0
+langsmith==0.4.4
+numpy==2.3.1
+openai==1.93.0
+openpyxl==3.1.5
+pymongo==4.13.2
+pythainlp==5.1.2
+python-dotenv==1.1.1
+regex==2024.11.6
+sentence-transformers==4.1.0
+transformers==4.53.0
+google-ai-generativelanguage==0.6.18
+google-api-core==2.25.1
+google-api-python-client==2.174.0
+google-auth==2.40.3
+google-auth-httplib2==0.2.0
+google-generativeai==0.8.5

utils/chat.py

@@ -0,0 +1,281 @@
+import os, re
+# os.environ["OTEL_TRACES_EXPORTER"] = "none"
+os.environ["OTEL_SDK_DISABLED"] = "true"
+
+import uuid
+from dotenv import load_dotenv
+
+from utils.chat_prompts import RAG_CHAT_PROMPT, NON_RAG_PROMPT
+from utils.reranker import RerankRetriever
+from utils.input_classifier import classify_input_type
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+from pymongo import MongoClient
+
+from langfuse.langchain import CallbackHandler
+from langfuse import observe
+
+load_dotenv()
+
+# MongoDB configurations
+mongo_username = os.environ.get('MONGO_USERNAME')
+mongo_password = os.environ.get('MONGO_PASSWORD')
+mongo_database = os.environ.get('MONGO_DATABASE')
+mongo_connection_str = os.environ.get('MONGO_CONNECTION_STRING')
+mongo_collection_name = os.environ.get('MONGO_COLLECTION')
+
+class ChatLaborLaw:
+    def __init__(self, model_name_llm="jai-chat-1-3-2", temperature=0):
+        self.session_id = str(uuid.uuid4())[:8]
+
+        # ----- Langfuse -----
+        self.langfuse_handler = CallbackHandler(
+        )
+        
+        self.history = [] # Store Langchain Message objects
+
+        self.model_name_llm = model_name_llm
+        self.retriever = RerankRetriever()
+
+        self.client = MongoClient(mongo_connection_str)
+        self.db = self.client[mongo_database]
+        self.collection = self.db[mongo_collection_name]
+
+        # --- LLM Initialization ---
+        if model_name_llm == "jai-chat-1-3-2":
+            self.llm_main = ChatOpenAI(
+                model=model_name_llm,
+                api_key=os.getenv("JAI_API_KEY"),
+                base_url=os.getenv("CHAT_BASE_URL"),
+                temperature=temperature,
+                max_tokens=2048,
+                max_retries=2,
+                seed=13
+            )
+
+        elif model_name_llm == "gemini-2.0-flash":
+            GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
+            if not GEMINI_API_KEY:
+                raise ValueError("GOOGLE_API_KEY (for Gemini) not found in environment variables.")
+            
+            common_gemini_config = {
+                "google_api_key": GEMINI_API_KEY,
+                "temperature": temperature,
+                "max_output_tokens": 2048, 
+                "convert_system_message_to_human": True, 
+            }
+            self.llm_main = ChatGoogleGenerativeAI(
+                model="gemini-2.0-flash", 
+                **common_gemini_config)
+
+        else:
+            raise ValueError(f"Unsupported LLM model '{model_name_llm}'.")
+
+        self.history = [] # Store Langchain Message objects
+
+
+    # ----- Context Retrieval -----
+    @observe(name='main_context')
+    def get_main_context(self, user_query, **kwargs):
+        # note ต้อง get ทุกครั้งไหม กรณีอะไรที่จะเปลี่ยน
+        # note ต้องมี classifier มาเพื่อตัดสิน filters -- * ถ้ามีระบุเวลา ก็ต้องไปคำนวน แล้วเอาจาก official_version แทน
+        compression_retriever = self.retriever.get_compression_retriever(**kwargs)
+        main_comtext_docs = compression_retriever.invoke(user_query)
+        return main_comtext_docs
+        
+    @observe(name='ref_context')
+    def get_ref_context(self, main_context_docs):
+        """
+        ค้นหา Context ของมาตราที่ถูกอ้างอิงจาก MongoDB
+        โดยใช้ $in operator เพื่อประสิทธิภาพสูงสุด
+        """
+        all_reference_docs = []
+
+        for context in main_context_docs:
+            references_list = context.metadata.get('references', [])
+
+            if not isinstance(references_list, list) or not references_list:
+                continue # ข้ามไป context ถัดไปถ้าไม่มีอ้างอิง
+
+            ref_numbers = [
+                ref_str.replace("มาตรา", "").strip() 
+                for ref_str in references_list
+            ]
+
+            # query $in : มาตรานั้นๆ
+            mongo_query = {
+                "law_type": "summary",
+                "section_number": {"$in": ref_numbers}
+            }
+            
+            projection = {
+                "_id": 1, 
+                "text": 1, 
+                "document_type": 1, 
+                "law_type": 1, 
+                "law_name": 1, 
+                # "publication_date": 1, 
+                # "effective_date": 1,
+                # "publication_date_utc": 1,
+                # "effective_date_utc": 1,
+                # "royal_gazette_volume": 1, 
+                # "royal_gazette_no": 1, 
+                # "royal_gazette_page": 1,
+                "chunk_type": 1, 
+                "section_number": 1
+            }
+
+            results = self.collection.find(mongo_query, projection)
+            all_reference_docs.extend(list(results))
+
+            # ลบอันที่ซ้ำ
+            ref_docs_by_id = {}
+            for doc in all_reference_docs:
+                ref_docs_by_id[doc["_id"]] = doc  # ถ้ามี _id ซ้ำกัน จะ overwrite
+
+            return list(ref_docs_by_id.values())
+
+
+    # handle main context
+    # ต้องเอา law_name, section_number (มาตรา), publication_date(ถ้ามี), effective_date(ถ้ามี)
+    def format_main_context(self, list_of_documents):
+        """
+        input: list of Document (Langchain)
+        output: text --> to forward to prompt
+        """
+        formatted_docs = []
+
+        for i, doc in enumerate(list_of_documents):
+            law_name = doc.metadata.get('law_name', '-')
+            section_number = doc.metadata.get('section_number', '-')
+            publication_date = doc.metadata.get('publication_date', '-') # ไม่ได้มีทุกอัน
+            effective_date = doc.metadata.get('effective_date', '-') # ไม่ได้มีทุกอัน
+            content = doc.page_content
+
+            formatted = "\n".join([
+                f"Doc{i}",
+                f"{law_name}",
+                f"มาตรา\t{section_number}",
+                content,
+                f"ประกาศ\t{publication_date}",
+                f"เริ่มใช้\t{effective_date}"
+            ])
+            
+            formatted_docs.append(formatted)
+
+        return "\n\n".join(formatted_docs)
+    
+
+    def format_ref_context(self, list_of_docs):
+        formatted_ref_docs = []
+
+        for i, doc in enumerate(list_of_docs):
+            law_name = doc.get('law_name', '-')
+            section_number = doc.get('section_number', '-')
+            content = doc.get('text', '-')
+
+            formatted = "\n".join([
+                f"{law_name}",
+                f"มาตรา\t{section_number}",
+                content,
+            ])
+            formatted_ref_docs.append(formatted)
+
+        return "\n\n".join(formatted_ref_docs)
+    
+    
+    # ----- Chat! -----
+
+    # History
+    def append_history(self, message: [HumanMessage, AIMessage]):
+        self.history.append(message)
+
+    def get_formatted_history_for_llm(self, n_turns: int = 3) -> list:
+        """Returns the last n_turns of history as a list of Message objects."""
+        return self.history[-(n_turns * 2):]
+
+
+    # Classify
+    @observe(name='classify_input_type')
+    def classify_input(self, user_input: str) -> str:
+        history_content_list = [msg.content for msg in self.history]  # เอาแค่ข้อความมา
+        return classify_input_type(user_input, history=history_content_list)
+    
+
+    # Chat
+    @observe(name="chat_flow")
+    async def chat(self, user_input: str) -> str:
+        history_before_current_input = self.history[:]
+        self.append_history(HumanMessage(content=user_input))
+
+        try:
+            input_type = self.classify_input(user_input)
+        except Exception as e:
+            print(f"Error classifying input type: {e}. Defaulting to Non-RAG.")
+            input_type = "Non-RAG"
+
+        ai_response_content = ""
+        if input_type == "RAG":
+            # print("[RAG FLOW]")
+            ai_response_content = await self.call_rag(user_input) #, history_before_current_input)
+        else: 
+            # print(f"[{input_type} FLOW (Treated as NON-RAG)]")
+            ai_response_content = await self.call_non_rag(user_input)
+
+        self.append_history(AIMessage(content=ai_response_content))
+        
+        # print(f"AI:::: {ai_response_content}")
+        return ai_response_content
+    
+
+    @observe(name='rag_flow')
+    async def call_rag(self, user_input: str) -> str:
+
+        # main context
+        context_docs = self.get_main_context(user_input, law_type="summary") # chunk_type='section'
+        # print(context_docs)
+        main_context_str = self.format_main_context(context_docs)
+
+        # ref context
+        ref_context_docs = self.get_ref_context(context_docs)
+        try:
+            ref_context_str = self.format_ref_context(ref_context_docs)
+        except:
+            ref_context_str = "-"
+
+        history_for_llm_prompt = self.get_formatted_history_for_llm(n_turns=3)
+
+        rag_input_data = {
+            "question": user_input,
+            "main_context": main_context_str,
+            "ref_context": ref_context_str,
+            "history": history_for_llm_prompt
+        }
+
+        try:
+            prompt_messages = RAG_CHAT_PROMPT.format_messages(**rag_input_data)
+            response = await self.llm_main.ainvoke(prompt_messages, config={"callbacks": [self.langfuse_handler]})
+            responsestring = response.content
+            clean_response = re.sub(r"<[^>]+>", "", responsestring)
+            clean_response = re.sub(r"#+", "", clean_response)
+            clean_response = clean_response.strip()
+            # return response.content.strip()
+            return clean_response
+
+        except Exception as e:
+            print(f"Error during RAG LLM call: {e}")
+            return "Sorry, I encountered an error while generating the response."
+
+    @observe(name='non_rag_flow')
+    async def call_non_rag(self, user_input: str) -> str:
+        prompt_messages = NON_RAG_PROMPT.format(user_input=user_input)
+        response = await self.llm_main.ainvoke(prompt_messages, config={"callbacks": [self.langfuse_handler]})
+        
+        # ป้องกัน content เป็น None
+        if not response or not response.content:
+            return "ขออภัย ระบบไม่สามารถตอบคำถามได้ในขณะนี้"
+
+        return response.content.strip()

utils/chat_prompts.py

@@ -0,0 +1,193 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate, SystemMessagePromptTemplate
+
+RAG_CHAT_PROMPT = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            """
+**Persona and Role:**
+You are a specialized AI assistant acting as a Thai legal expert. Your persona is helpful, precise, and authoritative. Your primary goal is to provide accurate and helpful answers to legal questions based exclusively on the provided Thai legal context.
+
+**Core Instructions:**
+
+1. Absolute Rules (Non-negotiable):
+• Language Constraint: You MUST respond in Thai only. Under no circumstances should you use English or any other language in your response.
+• Strict Grounding: Your answer must be derived strictly from the provided context. If the context does not contain the information to answer the user's question, you must state that you cannot answer based on the information given (in Thai). Do not invent, infer, or use any external knowledge.
+
+2. Context Handling and Reasoning:
+• Context Structure: The provided context will be divided into two types: Main Context and Ref Context.
+    - Main Context: Contains the primary legal articles retrieved directly for the user's query.
+    - Ref Context: Contains supporting legal articles that are referenced by name (e.g., 'ตามมาตรา ๑๑๘') within the Main Context.
+• Using Ref Context: You must intelligently decide whether the Ref Context is necessary to formulate a complete and accurate answer. Often, it will be essential for a comprehensive explanation.
+• Interpreting Internal References (<วรรค X>):
+    - The context may contain markers like <วรรค X> (meaning Paragraph X). You MUST NOT include these markers <> in your final output.
+    - However, you must understand their meaning to correctly interpret the law. For example, if a paragraph refers to "ตามวรรคหนึ่ง" (according to paragraph one), you must correctly resolve this reference to the content of the first paragraph of that same article.
+• Legal Terminology: When constructing your answer, use the formal legal terminology found within the provided context. Do not oversimplify the language into colloquial Thai.
+
+3. Output Formatting and Structure:
+• Clarity: Structure your answers clearly. Use bullet points, numbered lists, or distinct sections (e.g., separating different cases or scenarios) to make the information easy to understand.
+• Citations: At the end of your response, you MUST provide a summary of the legal sources you used. List all the specific articles (e.g., มาตรา ๑๑๘, มาตรา ๑๒๑) that you referenced to build your answer.
+
+
+**Example of Excellence**
+This is an example of an ideal interaction to guide your behavior.
+User Query:
+"ในกรณีที่นายจ้างเลิกจ้างลูกจ้างแล้วลูกจ้างนั้นทำงานติดต่อกันเกิน 6 ปีขึ้นไป นายจ้างจะต้องจ่ายค่าชดเชยเท่าไหร่"
+
+Provided Context:
+
+Main Context: "### มาตรา ๑๒๒
+ในกรณีที่นายจ้างเลิกจ้างลูกจ้างตามมาตรา ๑๒๑ และลูกจ้างนั้นทำงานติดต่อกันเกินหกปีขึ้นไป ให้นายจ้างจ่ายค่าชดเชยพิเศษเพิ่มขึ้นจากค่าชดเชยตามมาตรา ๑๑๘ ไม่น้อยกว่าค่าจ้างอัตราสุดท้ายสิบห้าวันต่อการทำงานครบหนึ่งปี หรือไม่น้อยกว่าค่าจ้างของการทำงานสิบห้าวันสุดท้ายต่อการทำงานครบหนึ่งปีสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย แต่ค่าชดเชยตามมาตรานี้รวมแล้วต้องไม่เกินค่าจ้างอัตราสุดท้ายสามร้อยหกสิบวัน หรือไม่เกินค่าจ้างของการทำงานสามร้อยหกสิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+"
+
+Ref Context: "### มาตรา ๑๒๑
+ในกรณีที่นายจ้างจะเลิกจ้างลูกจ้างเพราะเหตุที่นายจ้างปรับปรุงหน่วยงาน กระบวนการ��ลิต การจำหน่าย หรือการบริการอันเนื่องมาจากการนำเครื่องจักรมาใช้หรือเปลี่ยนแปลงเครื่องจักรหรือเทคโนโลยี ซึ่งเป็นเหตุให้ต้องลดจำนวนลูกจ้าง ห้ามมิให้นำมาตรา ๑๗ วรรคสอง มาใช้บังคับ และให้นายจ้างแจ้งวันที่จะเลิกจ้าง เหตุผลของการเลิกจ้างและรายชื่อลูกจ้างต่อพนักงานตรวจแรงงาน และลูกจ้างที่จะเลิกจ้างทราบล่วงหน้าไม่น้อยกว่าหกสิบวันก่อนวันที่จะเลิกจ้าง
+ในกรณีที่นายจ้างไม่แจ้งให้ลูกจ้างที่จะเลิกจ้างทราบล่วงหน้า หรือแจ้งล่วงหน้าน้อยกว่าระยะเวลาที่กำหนดตามวรรคหนึ่ง นอกจากจะได้รับค่าชดเชยตามมาตรา ๑๑๘ แล้ว ให้นายจ้างจ่ายค่าชดเชยพิเศษแทนการบอกกล่าวล่วงหน้าเท่ากับค่าจ้างอัตราสุดท้ายหกสิบวัน หรือเท่ากับค่าจ้างของการทำงานหกสิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วยด้วย
+ในกรณีที่มีการจ่ายค่าชดเชยพิเศษแทนการบอกกล่าวล่วงหน้าตามวรรคสองแล้ว ให้ถือว่านายจ้างได้จ่ายสินจ้างแทนการบอกกล่าวล่วงหน้าตามประมวลกฎหมายแพ่งและพาณิชย์ด้วย
+
+### มาตรา ๑๑๘
+ให้นายจ้างจ่ายค่าชดเชยให้แก่ลูกจ้างซึ่งเลิกจ้างดังต่อไปนี้
+(๑) ลูกจ้างซึ่งทำงานติดต่อกันครบหนึ่งร้อยยี่สิบวัน แต่ไม่ครบหนึ่งปี ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายสามสิบวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานสามสิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+(๒) ลูกจ้างซึ่งทำงานติดต่อกันครบหนึ่งปี แต่ไม่ครบสามปี ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายเก้าสิบวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานเก้าสิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+(๓) ลูกจ้างซึ่งทำงานติดต่อกันครบสามปี แต่ไม่ครบหกปี ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายหนึ่งร้อยแปดสิบวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานหนึ่งร้อยแปดสิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+(๔) ลูกจ้างซึ่งทำงานติดต่อกันครบหกปี แต่ไม่ครบสิบปี ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายสองร้อยสี่สิบวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานสองร้อยสี่สิบวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+(๕) ลูกจ้างซึ่งทำงานติดต่อกันครบสิบปี แต่ไม่ครบยี่สิบปี ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายสามร้อยวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานสามร้อยวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+(๖) ลูกจ้างซึ่งทำงานติดต่อกันครบยี่สิบปีขึ้นไป ให้จ่ายไม่น้อยกว่าค่าจ้างอัตราสุดท้ายสี่ร้อยวัน หรือไม่น้อยกว่าค่าจ้างของการทำงานสี่ร้อยวันสุดท้ายสำหรับลูกจ้างซึ่งได้รับค่าจ้างตามผลงานโดยคำนวณเป็นหน่วย
+การเลิกจ้างตามมาตรานี้ หมายความว่า การกระทำใดที่นายจ้างไม่ให้ลูกจ้างทำงานต่อไปและไม่จ่ายค่าจ้างให้ ไม่ว่าจะเป็นเพราะเหตุสิ้นสุดสัญญาจ้างหรือเหตุอื่นใด และหมายความรวมถึงกรณีที่ลูกจ้างไม่ได้"
+
+Ideal Response (Your output should look like this): "ตามข้อมูลจากพระราชบัญญัติคุ้มครองแรงงาน กรณีที่นายจ้างเลิกจ้างลูกจ้างซึ่งทำงานติดต่อกันเกิน 6 ปีขึ้นไป จำนวนค่าชดเชยที่จะได้รับจะขึ้นอยู่กับ "สาเหตุ" ของการเลิกจ้าง ซึ่งสามารถแบ่งได้เป็น 2 กรณีหลัก ดังนี้ครับ
+
+**กรณีที่ 1: การเลิกจ้างทั่วไป (ที่ไม่ได้เกิดจากเหตุตามมาตรา 121)**
+หากเป็นการเลิกจ้างทั่วไปที่ไม่ได้เกิดจากการปรับปรุงองค์กรโดยใช้เครื่องจักรหรือเทคโนโลยี นายจ้างจะต้องจ่ายค่าชดเชยตามปกติ ตามอายุงานของลูกจ้าง ซึ่งกำหนดไว้ในมาตรา 118 ดังนี้:
+*   ทำงานครบ 6 ปี แต่ไม่ครบ 10 ปี: ได้รับค่าชดเชยไม่น้อยกว่าค่าจ้างอัตราสุดท้าย 240 วัน
+*   ทำงานครบ 10 ปี แต่ไม่ครบ 20 ปี: ได้รับค่าชดเชยไม่น้อยกว่าค่าจ้างอัตราสุดท้าย 300 วัน
+*   ทำงานครบ 20 ปีขึ้นไป: ได้รับค่าชดเชยไม่น้อยกว่าค่าจ้างอัตราสุดท้าย 400 วัน
+
+**กรณีที่ 2: การเลิกจ้างเนื่องจากการปรับปรุงองค์กรโดยใช้เทคโนโลยี (ตามมาตรา 121)**
+หากนายจ้างเลิกจ้างเพราะเหตุปรับปรุงหน่วยงาน กระบวนการผลิต การจำหน่าย หรือการบริการ อันเนื่องมาจากการนำเครื่องจักรมาใช้หรือเปลี่ยนแปลงเทคโนโลยี ซึ่งทำให้ต้องลดจำนวนลูกจ้าง ลูกจ้างจะได้รับค่าชดเชย 2 ส่วนประกอบกัน คือ:
+1.  **ค่าชดเชยตามปกติ (ตามมาตรา 118):**
+    ลูกจ้างจะได้รับค่าชดเชยตามอายุงานเช่นเดียวกับกรณีที่ 1 (คือ 240, 300 หรือ 400 วัน ขึ้นอยู่กับอายุงาน)
+2.  **บวกกับ ค่าชดเชยพิเศษ (ตามมาตรา 122):**
+    นายจ้างต้องจ่ายค่าชดเชยพิเศษเพิ่มขึ้น ในอัตราไม่น้อยกว่าค่าจ้างอัตราสุดท้าย 15 วัน ต่อการทำงานครบ 1 ปี แต่ค่าชดเชยพิเศษนี้เมื่อรวมกันแล้วจะต้องไม่เกินค่าจ้างอัตราสุดท้าย 360 วัน
+
+**สรุป**
+จำนวนค่าชดเชยสำหรับลูกจ้างที่ทำงานเกิน 6 ปี จะแตกต่างกันอย่างมีนัยสำคัญขึ้นอยู่กับเหตุผลของการเลิกจ้าง หากเป็นเพราะการนำเทคโนโลยีมาใช้ตามมาตรา 121 ลูกจ้างจะได้รับค่าชดเชยปกติบวกด้วยค่าชดเชยพิเศษ ซึ่งจะทำให้ได้รับเงินชดเชยในจำนวนที่สูงกว่าการเลิกจ้างทั่วไป
+
+**ข้อควรทราบเพิ่มเติม:** กรณีเลิกจ้างตามมาตรา 121 นายจ้างมีหน้าที่ต้องแจ้งล่วงหน้าไม่น้อยกว่า 60 วัน หากไม่แจ้งหรือแจ้งน้อยกว่ากำหนด จะต้องจ่ายค่าชดเชยพิเศษแทนการบอกกล่าวล่วงหน้าเท่ากับค่าจ้าง 60 วัน เพิ่มเติมจากค่าชดเชยทั้งหมดด้วย
+
+**แหล่งข้อมูลอ้างอิง:**
+*   พระราชบัญญัติคุ้มครองแรงงาน
+*   มาตรา ๑๑๘ (ค่าชดเชยกรณีเลิกจ้างทั่วไป)
+*   มาตรา ๑๒๑ (เหตุเลิกจ้างเนื่องจากการนำเทคโนโลยีมาใช้ และค่าชดเชยพิเศษแทนการบอกกล่าวล่วงหน้า)
+*   มาตรา ๑๒๒ (ค่าชดเชยพิเศษกรณีเลิกจ้างตามมาตรา ๑๒๑)"
+"""
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        HumanMessagePromptTemplate.from_template(
+    """Based on the conversation history (if any) and the new question, generate an answer.
+IMPORTANT: Use the conversation history ONLY to understand the context of the user's question (like what 'that' or 'in this case' refers to).
+Your final answer MUST be based exclusively on the information within the 'Main Context' and 'Ref Context' provided below.
+
+Conversation History:
+{history}
+
+-----------------
+
+Provided Context for this turn:
+Main Context: {main_context}
+Ref Context: {ref_context}
+
+-----------------
+
+User's Current Question: {question}
+"""
+),
+    ]
+)
+
+
+
+from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate
+
+CLASSIFICATION_INPUT_PROMPT = ChatPromptTemplate.from_messages([
+    SystemMessagePromptTemplate.from_template(
+"""You are an expert AI classifier. Your primary function is to determine whether a user's query requires information from a specialized legal knowledge base (a process known as Retrieval-Augmented Generation or RAG). To make an accurate classification, you must analyze the 'User Input' in conjunction with the 'Chat History' to grasp the full conversational context and the user's true intent.
+
+**Your classification decision must be based on the following strict criteria:**
+
+---
+
+**1. Classify as "RAG" if the query is related to Thai labor law or its legal hierarchy.**
+
+This includes, but is not limited to:
+*   **Direct questions about Thai Labor Law:** (กฎหมายแรงงาน)
+    *   Specific scenarios requiring legal interpretation.
+    *   Examples: "My employer isn't paying my salary, what can I do?" (นายจ้างไม่จ่ายเงิน), "How many vacation days am I entitled to per year?" (พนักงานมีสิทธิลาได้กี่วันต่อปี)
+*   **Questions about the hierarchy and types of Thai laws:** (ลำดับชั้นของกฎหมายไทย)
+    *   **Constitution:** (รัฐธรรมนูญ) - The supreme law of the land.
+    *   **Organic Act:** (พระราชบัญญัติประกอบรัฐธรรมนูญ) - Acts elaborating on the Constitution.
+    *   **Act:** (พระราชบัญญัติ) - Laws enacted by the Parliament.
+    *   **Emergency Decree:** (พระราชกำหนด) - Decrees issued by the Cabinet in urgent cases.
+    *   **Royal Decree:** (พระราชกฤษฎีกา) - Decrees issued by the King on the Cabinet's advice to detail an Act.
+    *   **Ministerial Regulation:** (กฎกระทรวง) - Regulations issued by a Minister to implement an Act.
+    *   **Local Ordinance:** (ข้อบัญญัติท้องถิ่น) - Laws issued by local administrative organizations.
+
+---
+
+**2. Classify as "Non-RAG" if the query falls into any of the following categories, even when considering the chat history:**
+
+*   **General Conversation & Small Talk:** Greetings, chitchat, or questions that do not require specialized knowledge (e.g., "How are you?", "What's the weather like?").
+*   **General Knowledge Questions:** Inquiries answerable with common knowledge and not specific to the legal database (e.g., "Who is the president of the USA?").
+*   **Sensitive or Opinion-Based Topics:** Personal opinions, political discussions, topics about the monarchy, or general religious discussions.
+*   **Unrelated Services or Competitors:** Questions about other companies, services, or topics completely outside the scope of Thai labor law.
+
+---
+
+**Instructions for Output:**
+-   After your analysis, you must respond with **one single word only**.
+-   Your response must be either `RAG` or `Non-RAG`.
+-   Do not provide any explanations or additional text.
+
+**Context for Analysis:**
+Chat History:
+{chat_history}
+
+User Input: "{user_input}"
+
+**Your Classification:**
+"""
+    )
+])
+
+
+
+
+from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+
+NON_RAG_PROMPT = ChatPromptTemplate.from_messages([
+    SystemMessagePromptTemplate.from_template(
+        """You are a highly specialized AI assistant with a strict and defined scope. Your persona is that of a polite, professional, and gender-neutral expert.
+
+        **Your Primary Directive:**
+        Your task is to formulate a response to the user, and **your response MUST be 100% in the Thai language.**
+
+        **Core Task & Conditional Logic:**
+        You must analyze the user's input and choose ONE of the following two scenarios to formulate your response.
+
+        ---
+        **Scenario A: The input is a simple greeting.**
+        -   **Condition:** The user's input is a standard greeting, a simple hello, or a basic introduction (e.g., "สวัสดี", "ดีครับ", "Hello").
+        -   **Required Action:** Respond with a professional, welcoming message that invites the user to ask a question about Thai labor law.
+        -   **[Response Example in Thai]:** "ระบบพร้อมให้ข้อมูลเกี่ยวกับกฎหมายแรงงานไทย มีข้อสงสัยใดให้ช่วยเหลือ สามารถสอบถามได้"
+
+        ---
+        **Scenario B: The input is any other out-of-scope topic.**
+        -   **Condition:** The user's input is not a greeting and is not related to Thai labor law (e.g., general knowledge, politics, chit-chat).
+        -   **Required Action:** Politely inform the user that their question is outside your area of expertise. **DO NOT** attempt to answer the user's original question under any circumstances.
+        -   **[Response Example in Thai]:** "ขออภัย ระบบสามารถให้ข้อมูลได้เฉพาะในขอบเขตของกฎหมายแรงงานไทยเท่านั้น หากท่านมีคำถามที่เกี่ยวข้อง โปรดสอบถาม"
+        ---
+
+        Now, based on these rules and scenarios, formulate the single, most appropriate Thai response for the following user input.
+        """
+    ),
+    HumanMessagePromptTemplate.from_template("User Input: '{user_input}'")
+])

utils/input_classifier.py

@@ -0,0 +1,93 @@
+# from openai import OpenAI
+from dotenv import load_dotenv
+import os
+from utils.chat_prompts import CLASSIFICATION_INPUT_PROMPT
+# from google import genai
+from openai import OpenAI
+import random, time
+
+load_dotenv()
+
+client_jai = OpenAI(
+    api_key=os.environ.get("JAI_API_KEY"),
+    base_url=os.environ.get("CHAT_BASE_URL")
+)
+model = "jai-chat-1-3-2"
+# model = "openthaigpt72b"
+
+# gemi = os.environ["GEMINI_API_KEY"]
+# client_jai = genai.Client(api_key=gemi)
+# model = "gemini-2.0-flash"
+# temperature = 0.0
+
+def generate_content_with_retry(client, model, prompt, max_retries=3):
+    """
+    Helper function to call client.models.generate_content with retry logic.
+    """
+    for attempt in range(max_retries):
+        try:
+            # response = client.models.generate_content( # gemi
+            response = client.chat.completions.create(
+                model=model,
+                messages = [{"role": "user", "content": prompt}]
+                # contents=prompt, # gemi
+                # temperature=temperature,  # Optional:  Restore if needed
+            )
+            # return response.text.strip()  # Return the result if successful # gemi
+            return response.choices[0].message.content
+
+
+        except Exception as e:
+            if hasattr(e, 'code') and e.code == 503: # Check for the 503 error
+                print(f"Attempt {attempt + 1} failed with 503 error: {e}")
+                wait_time = (2 ** attempt) + random.random()  # Exponential backoff
+                print(f"Waiting {wait_time:.2f} seconds before retrying...")
+                time.sleep(wait_time)
+            else:
+                print(f"Attempt {attempt + 1} failed with a different error: {e}")
+                raise  # Re-raise the exception if it's not a 503
+
+    print(f"Failed to generate content after {max_retries} retries.")
+    return None # Or raise an exception, depending on desired behavior
+
+
+def classify_input_type(user_input: str, history: list = None) -> str:
+    """
+    Classifies the user input as 'RAG' or 'Non-RAG' using the LLM, considering chat history.
+    Supports history as a list of strings or a list of dicts with 'type' and 'content'.
+    """
+    history_text = "None"
+
+    if history:
+        formatted_history = []
+
+        for i, msg in enumerate(history[-3:]):
+            # Case: history is list of dicts
+            if isinstance(msg, dict):
+                role = "Human" if msg.get("type") == "human" else "AI" # changed dash to human and aie
+                content = msg.get("content", "")
+            # Case: history is list of strings, alternate roles
+            elif isinstance(msg, str):
+                role = "Human" if (len(history[-3:]) - i) % 2 == 1 else "AI"
+                content = msg
+            else:
+                continue  # skip invalid entry
+
+            formatted_history.append(f"{role}: {content}")
+
+        history_text = "\n".join(formatted_history)
+
+    formatted_messages = CLASSIFICATION_INPUT_PROMPT.format(
+        user_input=user_input,
+        chat_history=history_text
+    )
+
+    prompt_content = formatted_messages
+    # print(prompt_content)
+
+    result = generate_content_with_retry(client_jai, model, prompt_content)
+
+    if result is None:
+        raise Exception("Failed to classify input type after multiple retries.")
+
+    return result

utils/reranker.py

@@ -0,0 +1,46 @@
+from langchain.retrievers import ContextualCompressionRetriever
+from langchain.retrievers.document_compressors import CrossEncoderReranker
+from langchain_community.cross_encoders import HuggingFaceCrossEncoder
+from utils.retriever import get_retriever
+
+# -- HuggingFaceCrossEncoder
+# https://python.langchain.com/docs/integrations/document_transformers/cross_encoder_reranker/
+
+
+# ---- Configurations for model ----
+MODEL = HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-base")
+TOP_N = 5
+COMPRESSOR = CrossEncoderReranker(model=MODEL, 
+                                  top_n=TOP_N)
+
+
+# ---- Reranker Retriever ----
+class RerankRetriever:
+    def __init__(self):
+        pass
+    
+    def get_base_retriever(self, **kwargs):
+        filters = {**kwargs}
+        retriever = get_retriever(**filters)
+        return retriever
+
+    def get_compression_retriever(self, **kwargs):
+
+        # ---- get_base_retriever ----
+        base_retriever_used = self.get_base_retriever(**kwargs)
+
+        # ---- Instantiate compression retriever ----
+        compression_retriever = ContextualCompressionRetriever(
+            base_compressor=COMPRESSOR,
+            base_retriever=base_retriever_used,
+            tags=["qa_retriever", "rerank"]
+        )
+
+        return compression_retriever
+
+    def pretty_print_docs(self, docs):
+        return(
+            f"\n{'-' * 100}\n".join(
+                [f"Document {i+1}:\n\n" + d.page_content for i, d in enumerate(docs)]
+            )
+        )

utils/retriever.py

@@ -0,0 +1,68 @@
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
+from langchain_mongodb.retrievers.hybrid_search import MongoDBAtlasHybridSearchRetriever
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ---- MongoDB credentials ----
+mongo_username = os.getenv('MONGO_USERNAME')
+mongo_password = os.getenv('MONGO_PASSWORD')
+mongo_database = os.getenv('MONGO_DATABASE')
+mongo_connection_str = os.getenv('MONGO_CONNECTION_STRING')
+mongo_collection_name = os.getenv('MONGO_COLLECTION')
+
+# ---- Common Configurations & Hybrid Retrieval Configuration ----
+MODEL_KWARGS = {"device": "cpu"}
+ENCODE_KWARGS = {"normalize_embeddings": True,
+                 "batch_size": 32}
+EMBEDDING_DIMENSIONS = 1024
+MODEL_NAME = "BAAI/bge-m3"
+FINAL_TOP_K = 10
+HYBRID_FULLTEXT_PENALTY = 60
+HYBRID_VECTOR_PENALTY = 60
+
+# ---- Embedding model ----
+embed_model = HuggingFaceEmbeddings(
+    model_name=MODEL_NAME, 
+    model_kwargs=MODEL_KWARGS, 
+    encode_kwargs=ENCODE_KWARGS
+)
+
+# ---- Vectore Search ----
+num_vector_candidates = max(20, 2 * FINAL_TOP_K)
+num_text_candidates = max(20, 2 * FINAL_TOP_K)
+vector_k = num_vector_candidates
+vector_num_candidates_for_operator = vector_k * 10
+
+# ---- Vectore Store ----
+vector_store = MongoDBAtlasVectorSearch.from_connection_string(
+    connection_string=mongo_connection_str,
+    namespace=f"{mongo_database}.{mongo_collection_name}",
+    embedding=embed_model,
+    index_name="search_index_v1",
+)
+
+# ---- Retriever (Hybrid) ----
+def get_retriever(**kwargs):
+    retriever = MongoDBAtlasHybridSearchRetriever(
+        vectorstore=vector_store,
+        search_index_name='search_index_v1',
+        embedding=embed_model,
+        text_key= 'text', #'token',
+        embedding_key='embedding',
+        top_k=FINAL_TOP_K,
+        vector_penalty=HYBRID_VECTOR_PENALTY,
+        fulltext_penalty=HYBRID_FULLTEXT_PENALTY,
+        vector_search_params={
+            "k": vector_k,
+            "numCandidates": vector_num_candidates_for_operator
+        },
+        text_search_params={
+            "limit": num_text_candidates
+        },
+        pre_filter=kwargs
+    )
+    return retriever
+