commit

.gitignore

@@ -0,0 +1,22 @@
+temp_data/
+poc_data/
+__pycache__/
+app/feedback/
+
+# Jupyter Notebook
+*.ipynb_checkpoints
+*.ipynb
+
+# Environments
+.env
+.venv
+.gradio/
+credentials.json
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+secrets/
+
+*.DS_Store

app.py

@@ -1,64 +1,173 @@
 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 os
+import uuid
+from chat_3 import Chat
+
+# Function to initialize a new session and create chatbot instance for that session
+def initialize_session():
+    session_id = str(uuid.uuid4())[:8]  # Generate unique session ID
+    chatbot = Chat()  # Create a new Chat instance for this session
+    # chatbot = Chat("gemini-2.0-flash")
+    history = []  # Initialize history for this session
+    return "", session_id, chatbot, history  # "" for clearing input
+
+# Function to handle user input and chatbot response
+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 = chatbot.chat(prompt)
+
+    # Append the assistant's response to the message history
+    history.append({"role": "assistant", "content": response})
+
+    return history, "", session_id, chatbot  # Clear input
+
+# Function to save feedback with chat history
+def send_feedback(feedback, history, session_id, chatbot):
+    os.makedirs("app/feedback", exist_ok=True)  # Create folder if not exists
+    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="pink")) as demo:
+    gr.Markdown("# Hey Beauty Chatbot 🧖🏻‍♀️✨🌿")
+    gr.Markdown("สวัสดีค่ะ Hey Beauty ยินดีให้บริการค่ะ")
+
+    # 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)
+# demo.launch()
+
+
+# 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()

chat_3.py

@@ -0,0 +1,353 @@
+import os
+import uuid
+from dotenv import load_dotenv
+
+from utils.chat_prompts import (
+    NON_RAG_PROMPT,
+    RAG_CHAT_PROMPT_ENG,
+    RAG_CHAT_PROMPT_TH,
+    RAG_CHAT_PROMPT_KOREAN,
+    QUERY_REWRITING_PROMPT_OBJ
+)
+from get_retriever_2 import final_retrievers # Retriever ที่อาจผ่านการ rerank
+from input_classifier import classify_input_type, detect_language
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+from langfuse.callback import CallbackHandler
+
+# Load environment variables from .env file
+load_dotenv()
+
+langfuse_handler = CallbackHandler(
+  secret_key=os.environ['LANGFUSE_SECRET_KEY'],
+  public_key=os.environ['LANGFUSE_PUBLIC_KEY'],
+  host="https://us.cloud.langfuse.com"
+)
+
+class Chat:
+    def __init__(self, model_name_llm="jai-chat-1-3-2", temperature=0):
+        self.session_id = str(uuid.uuid4())[:8]
+        self.model_name_llm = model_name_llm # เก็บชื่อโมเดลไว้เผื่อใช้
+
+        # --- LLM Initialization ---
+        # เราจะสร้าง LLM สำหรับการตอบคำถามหลัก และอาจจะใช้ตัวเดียวกันหรือตัวที่เล็กกว่าสำหรับ Query Rewriting
+        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
+            )
+            # สำหรับ query rewriting, ถ้า JAI มี model ที่เร็วกว่า/ถูกกว่า ก็สามารถใช้ตัวนั้นได้
+            # หรือใช้ตัวเดียวกันไปก่อน
+            self.llm_rewriter = self.llm_main
+        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, # ใช้ max_output_tokens สำหรับ Gemini
+                "convert_system_message_to_human": True, # สำคัญสำหรับ Gemini
+                # "top_p": 0.95,
+                # "top_k": 40,
+            }
+            self.llm_main = ChatGoogleGenerativeAI(
+                model="gemini-1.5-flash-latest", # e.g., "gemini-1.5-flash-latest" or "gemini-1.5-pro-latest"
+                **common_gemini_config
+            )
+            # Gemini มี "gemini-1.5-flash-latest" ที่เหมาะกับงานเร็วๆ เช่น rewriting
+            # ถ้า llm_main เป็น pro, อาจจะใช้ flash สำหรับ rewriter
+            # ในที่นี้ถ้า llm_main เป็น flash อยู่แล้ว ก็ใช้ตัวเดียวกัน
+            self.llm_rewriter = ChatGoogleGenerativeAI(
+                model="gemini-2.0-flash", # หรือ model_name_llm ถ้ามันคือ flash อยู่แล้ว
+                **common_gemini_config
+            )
+
+        else:
+            raise ValueError(f"Unsupported LLM model '{model_name_llm}'.")
+
+        self.history = [] # Store Langchain Message objects
+
+    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):]
+
+    def get_stringified_history_for_rewrite(self, n_turns: int = 2) -> str:
+        """
+        Formats the last n_turns of history (excluding the current un-added user input)
+        as a string for the query rewriter prompt.
+        """
+        history_to_format = self.history[-(n_turns * 2):]
+        if not history_to_format:
+            return "No history available."
+
+        history_str_parts = []
+        for msg in history_to_format:
+            role = "User" if isinstance(msg, HumanMessage) else "AI"
+            history_str_parts.append(f"{role}: {msg.content}")
+        return "\n".join(history_str_parts)
+
+    def classify_input(self, user_input: str) -> str:
+        history_content_list = [msg.content for msg in self.history] # เอาเฉพาะ content
+        return classify_input_type(user_input, history=history_content_list)
+
+    def format_docs(self, docs: list) -> str:
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    def get_retriever_and_prompt(self, lang_code: str):
+        """
+        Returns the appropriate retriever and RAG prompt based on the language.
+        Handles potential errors if retriever or prompt is not found.
+        """
+        retriever = final_retrievers.get(lang_code)
+        
+        if lang_code == "Thai":
+            prompt_template = RAG_CHAT_PROMPT_TH
+        elif lang_code == "Korean":
+            prompt_template = RAG_CHAT_PROMPT_KOREAN
+        elif lang_code == "English":
+            prompt_template = RAG_CHAT_PROMPT_ENG
+        else:
+            print(f"Warning: Unsupported language '{lang_code}' for RAG. Defaulting to English.")
+            retriever = final_retrievers.get('English') # Default to English
+            prompt_template = RAG_CHAT_PROMPT_ENG
+
+        if not retriever:
+            # Attempt to get any available retriever if the specific or default English one is missing
+            available_langs = list(final_retrievers.keys())
+            if available_langs:
+                fallback_lang = available_langs[0]
+                retriever = final_retrievers[fallback_lang]
+                print(f"Warning: No retriever for '{lang_code}' or 'English'. Using first available: '{fallback_lang}'.")
+                # Match prompt to this fallback retriever if possible
+                if fallback_lang == "Thai": prompt_template = RAG_CHAT_PROMPT_TH
+                elif fallback_lang == "Korean": prompt_template = RAG_CHAT_PROMPT_KOREAN
+                else: prompt_template = RAG_CHAT_PROMPT_ENG # Default to English prompt anyway
+            else:
+                raise ValueError("CRITICAL: No retrievers configured at all.")
+
+        if not prompt_template: # Should not happen if logic above is correct
+             raise ValueError(f"CRITICAL: No RAG prompt template found for language '{lang_code}' or effective fallback.")
+            
+        return retriever, prompt_template
+
+    def _rewrite_query_if_needed(self, user_input: str, input_lang: str) -> str:
+        """
+        Internal method to rewrite the user query using chat history if there is history.
+        """
+        if not self.history: # No history, no need to rewrite
+            return user_input
+
+        chat_history_str = self.get_stringified_history_for_rewrite(n_turns=2)
+
+        try:
+            rewrite_prompt_messages = QUERY_REWRITING_PROMPT_OBJ.format_messages(
+                chat_history=chat_history_str,
+                question=user_input
+            )
+            
+            response = self.llm_rewriter.invoke(rewrite_prompt_messages)
+            rewritten_query = response.content.strip()
+
+            # Basic validation of rewritten query
+            if rewritten_query and len(rewritten_query) < (len(user_input) + 250) and len(rewritten_query) > 0: # Avoid empty or overly long
+                print(f"Original query: '{user_input}', Rewritten query for retriever: '{rewritten_query}'")
+                return rewritten_query
+            else:
+                print(f"Rewritten query validation failed or empty. Using original: '{user_input}'")
+                return user_input
+        except Exception as e:
+            print(f"Error during query rewriting: {e}. Using original query.")
+            return user_input
+
+    def call_rag(self, user_input: str, input_lang: str) -> str:
+        try:
+            retriever, selected_rag_prompt = self.get_retriever_and_prompt(input_lang)
+        except ValueError as e:
+            print(f"Error in RAG setup: {e}")
+            return f"Sorry, I encountered a configuration issue for {input_lang} RAG. Please contact support."
+
+        # --- Query Rewriting Step ---
+        # user_input is the current question. self.history does not yet contain it.
+        query_for_retriever = self._rewrite_query_if_needed(user_input, input_lang)
+
+        print(f"Retrieving documents for query: '{query_for_retriever}' (lang: {input_lang})")
+        try:
+            context_docs = retriever.invoke(query_for_retriever)
+        except Exception as e:
+            print(f"Error during document retrieval: {e}")
+            return "Sorry, I had trouble finding relevant information for your query."
+        
+        print(f"Retrieved {len(context_docs)} documents. (Max possible after rerank: {os.getenv('FINAL_TOP_K_RERANK', 'N/A')})")
+        # for i, doc in enumerate(context_docs):
+        # print(f"  Doc {i+1} (Score: {doc.metadata.get('rerank_score', 'N/A')}): {doc.page_content[:100]}...")
+
+        context_str = self.format_docs(context_docs)
+        
+        # History for the RAG prompt (LLM context)
+        history_for_llm_prompt = self.get_formatted_history_for_llm(n_turns=3)
+
+        rag_input_data = {
+            "question": user_input, # Use the original user_input for the question to LLM
+            "context": context_str,
+            "history": history_for_llm_prompt # Pass Langchain Message objects
+        }
+
+        try:
+            prompt_messages = selected_rag_prompt.format_messages(**rag_input_data)
+            # print(f"DEBUG: RAG Prompt Messages: {prompt_messages}")
+            # response = self.llm_main.invoke(prompt_messages)
+            response = self.llm_main.invoke(prompt_messages, config={"callbacks": [langfuse_handler]})
+            return response.content.strip()
+        except Exception as e:
+            print(f"Error during RAG LLM call: {e}")
+            return "Sorry, I encountered an error while generating the response."
+
+    def call_non_rag(self, user_input: str, input_lang: str) -> str:
+        # Ensure NON_RAG_PROMPT is a ChatPromptTemplate or a string
+        try:
+            if hasattr(NON_RAG_PROMPT, "format_messages"): # Is a ChatPromptTemplate
+                prompt_messages = NON_RAG_PROMPT.format(user_input=user_input, input_lang=input_lang)
+            elif isinstance(NON_RAG_PROMPT, str): # Is a plain string template
+                formatted_prompt_str = NON_RAG_PROMPT.format(user_input=user_input, input_lang=input_lang)
+                prompt_messages = [HumanMessage(content=formatted_prompt_str)]
+            else:
+                raise TypeError("NON_RAG_PROMPT is of an unsupported type.")
+            
+            # response = self.llm_main.invoke(prompt_messages)
+            response = self.llm_main.invoke(prompt_messages, config={"callbacks": [langfuse_handler]})
+
+            return response.content.strip()
+
+        except Exception as e:
+            print(f"Error during Non-RAG LLM call: {e}")
+            return "Sorry, I had trouble processing your general request."
+
+    def chat(self, user_input: str) -> str:
+        print(f"\n\n-- USER INPUT: {user_input} --")
+        
+        # 1. Detect language of the current user input
+        # This should ideally be robust and return one of "Thai", "Korean", "English"
+        # or a defined set that get_retriever_and_prompt can handle.
+        try:
+            input_lang_detected = detect_language(user_input)
+            print(f"Language detected: {input_lang_detected}")
+        except Exception as e:
+            print(f"Error detecting language: {e}. Defaulting to Thai.") # Or your most common language
+            input_lang_detected = "Thai"
+
+        history_before_current_input = self.history[:] # Make a copy of history *before* appending current input
+
+        # Append current user input to history
+        self.append_history(HumanMessage(content=user_input))
+        
+        # 3. Classify input type based on current input and now-updated history
+        try:
+            input_type = self.classify_input(user_input) # classify_input now sees history with current 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]")
+            # Pass the original user_input and the detected language.
+            # call_rag will handle query rewriting internally using history_before_current_input
+            ai_response_content = self.call_rag_v2(user_input, input_lang_detected, history_before_current_input)
+        else: # "Non-RAG" or any other classification
+            print(f"[{input_type} FLOW (Treated as NON-RAG)]")
+            ai_response_content = self.call_non_rag(user_input, input_lang_detected)
+
+        # 4. Append AI response to history
+        self.append_history(AIMessage(content=ai_response_content))
+        
+        print(f"AI:::: {ai_response_content}")
+        return ai_response_content
+
+
+    # New call_rag version that accepts history_before_current_input
+    def call_rag_v2(self, user_input: str, input_lang: str, history_for_rewrite: list) -> str:
+        try:
+            retriever, selected_rag_prompt = self.get_retriever_and_prompt(input_lang)
+        except ValueError as e:
+            print(f"Error in RAG setup: {e}")
+            return f"Sorry, I encountered a configuration issue for {input_lang} RAG. Please contact support."
+
+        # --- Query Rewriting Step ---
+        query_for_retriever = self._rewrite_query_if_needed_v2(user_input, history_for_rewrite)
+
+
+        print(f"Retrieving documents for query: '{query_for_retriever}' (lang: {input_lang})")
+        try:
+            context_docs = retriever.invoke(query_for_retriever)
+        except Exception as e:
+            print(f"Error during document retrieval: {e}")
+            return "Sorry, I had trouble finding relevant information for your query."
+        
+        print(f"Retrieved {len(context_docs)} documents.")
+
+        context_str = self.format_docs(context_docs)
+        print(f"\n----> CONTEXT DOCS (from call_rag_v2)\n{context_str}")
+        
+        # History for the RAG prompt (LLM context) - this should be the full history *including* current user_input
+        history_for_llm_prompt = self.get_formatted_history_for_llm(n_turns=3)
+
+
+        rag_input_data = {
+            "question": user_input,
+            "context": context_str,
+            "history": history_for_llm_prompt
+        }
+
+        try:
+            prompt_messages = selected_rag_prompt.format_messages(**rag_input_data)
+            # response = self.llm_main.invoke(prompt_messages)
+            response = self.llm_main.invoke(prompt_messages, config={"callbacks": [langfuse_handler]})
+
+            return response.content.strip()
+
+        except Exception as e:
+            print(f"Error during RAG LLM call: {e}")
+            return "Sorry, I encountered an error while generating the response."
+
+    # New rewrite_query version that accepts history
+    def _rewrite_query_if_needed_v2(self, user_input: str, history_list: list) -> str:
+        if not history_list:
+            return user_input
+
+        # Format the passed history_list (which is before current user_input)
+        history_str_parts = []
+        for msg in history_list[-(2*2):]: # Take last 2 turns from the provided history
+             role = "User" if isinstance(msg, HumanMessage) else "AI"
+             history_str_parts.append(f"{role}: {msg.content}")
+        chat_history_str = "\n".join(history_str_parts) if history_str_parts else "No relevant history."
+
+        try:
+            rewrite_prompt_messages = QUERY_REWRITING_PROMPT_OBJ.format_messages(
+                chat_history=chat_history_str,
+                question=user_input
+            )
+            response = self.llm_rewriter.invoke(rewrite_prompt_messages)
+            rewritten_query = response.content.strip()
+
+            if rewritten_query and len(rewritten_query) < (len(user_input) + 250) and len(rewritten_query) > 0:
+                print(f"Original query: '{user_input}', Rewritten query for retriever: '{rewritten_query}'")
+                return rewritten_query
+            else:
+                print(f"Rewritten query validation failed. Using original: '{user_input}'")
+                return user_input
+        except Exception as e:
+            print(f"Error during query rewriting: {e}. Using original query.")
+            return user_input

get_retriever_2.py

@@ -0,0 +1,340 @@
+import os
+from dotenv import load_dotenv
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
+from langchain_mongodb.retrievers.hybrid_search import MongoDBAtlasHybridSearchRetriever
+from langchain.retrievers import ContextualCompressionRetriever # <--- เพิ่มกลับเข้ามา
+
+from reranker import (
+    rerank_documents,
+    RERANKER_MODEL_NAME,
+    FINAL_TOP_K_RERANK,
+    get_reranker_compressor
+)
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Retrieve MongoDB credentials and cluster from environment variables
+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')
+
+# --- Common Configurations ---
+MODEL_KWARGS = {"device": "cpu"} # สำหรับ embedding model
+ENCODE_KWARGS = {"normalize_embeddings": True}
+EMBEDDING_DIMENSIONS = 384
+
+# --- Configurations for Hybrid Retrieval with Reranking ---
+# จำนวนเอกสารที่จะดึงมาเบื้องต้นเพื่อให้ reranker
+CANDIDATES_FOR_RERANKING = int(os.getenv("CANDIDATES_FOR_RERANKING", 20))
+ACTUAL_FINAL_TOP_K = int(os.getenv("FINAL_TOP_K_RERANK", FINAL_TOP_K_RERANK))
+ACTUAL_RERANKER_MODEL_NAME = os.getenv("RERANKER_MODEL_NAME", RERANKER_MODEL_NAME)
+
+# Configuration สำหรับ Hybrid Retriever -- initiai
+INITIAL_HYBRID_KWARGS = {
+    "k": CANDIDATES_FOR_RERANKING,
+    # "score_threshold": 0.1, # อาจจะไม่ต้องใช้ threshold ที่นี่ ให้ reranker ตัดสิน
+}
+
+HYBRID_FULLTEXT_PENALTY = 60
+HYBRID_VECTOR_PENALTY = 60
+HYBRID_TEXT_KEY = "page_content"
+
+# --- Language-Specific Configurations ---
+LANGUAGE_CONFIGS = [
+    {
+        "code": "Thai",
+        "model_name": "intfloat/multilingual-e5-small",
+        "collection_env_var": "MONGO_COLLECTION",
+        "vector_search_index_name": "vector_index_th",
+        "atlas_search_index_name": "search_index_th"
+    },
+    {
+        "code": "English",
+        "model_name": "intfloat/e5-small",
+        "collection_env_var": "MONGO_COLLECTION_ENG",
+        "vector_search_index_name": "vector_index_eng",
+        "atlas_search_index_name": "search_index_eng"
+    },
+    {
+        "code": "Korean",
+        "model_name": "intfloat/multilingual-e5-small",
+        "collection_env_var": "MONGO_COLLECTION_KOR",
+        "vector_search_index_name": "vector_index_kor",
+        "atlas_search_index_name": "search_index_kor"
+    },
+]
+
+# Dictionaries to store initialized retrievers
+final_retrievers = {} # <--- เปลี่ยนกลับมาเป็น final_retrievers
+
+# --- Reranker Setup (ทำครั้งเดียวถ้า config เหมือนกัน) ---
+# เราจะใช้ get_reranker_compressor ที่ cache instance
+# โดยจะสร้าง compressor ตอนที่ต้องการใช้จริงใน ContextualCompressionRetriever
+# หรือจะสร้างไว้ล่วงหน้าถ้า config ไม่เปลี่ยนตามภาษา
+# ในที่นี้ เราจะสมมติว่าใช้ reranker model เดียวกันทุกภาษา
+# ถ้าต้องการ reranker model ต่างกันตามภาษา ต้องปรับ logic นี้
+USE_RERANKER_FLAG = os.getenv("USE_RERANKER", "true").lower() == "true"
+
+print(f"\n--- Reranker Configuration ---")
+if USE_RERANKER_FLAG:
+    print(f"Reranking: ENABLED")
+    print(f"Reranker Model: {ACTUAL_RERANKER_MODEL_NAME}")
+    print(f"Candidates for Reranker (Hybrid K1): {CANDIDATES_FOR_RERANKING}")
+    print(f"Final Documents after Rerank (K2): {ACTUAL_FINAL_TOP_K}")
+    # ลองโหลด reranker compressor ที่นี่เพื่อทดสอบว่าโหลดได้ไหม
+    try:
+        test_compressor = get_reranker_compressor(
+            model_name=ACTUAL_RERANKER_MODEL_NAME,
+            top_n=ACTUAL_FINAL_TOP_K
+        )
+        print("Reranker compressor pre-warmed/loaded successfully.")
+    except Exception as e:
+        print(f"WARNING: Could not pre-load/initialize reranker: {e}")
+        print("Reranking might fail or be disabled implicitly if model loading fails later.")
+        # USE_RERANKER_FLAG = False # Optionally disable reranking if pre-load fails
+else:
+    print(f"Reranking: DISABLED")
+    print(f"Hybrid Retriever K (direct results): {CANDIDATES_FOR_RERANKING if not USE_RERANKER_FLAG else ACTUAL_FINAL_TOP_K}") # ปรับตาม logic
+
+# --- Setup Loop for Each Language ---
+for config in LANGUAGE_CONFIGS:
+    lang_code = config["code"]
+    model_name = config["model_name"]
+    collection_name_env = config["collection_env_var"]
+    vector_idx_name = config["vector_search_index_name"]
+    atlas_search_idx_name = config["atlas_search_index_name"]
+
+    mongo_collection_name = os.getenv(collection_name_env)
+
+    if not mongo_collection_name or not mongo_database or not mongo_connection_str:
+        print(f"Warning: MongoDB config missing for {lang_code.upper()}. Skipping.")
+        continue
+
+    print(f"\n--- Setting up for {lang_code.upper()} ---")
+    print(f"Collection: {mongo_collection_name}, Embedding Model: {model_name}")
+    print(f"Vector Search Index: {vector_idx_name}, Atlas Search Index (for Hybrid): {atlas_search_idx_name}")
+
+    try:
+        embed_model = HuggingFaceEmbeddings(
+            model_name=model_name,
+            model_kwargs=MODEL_KWARGS,
+            encode_kwargs=ENCODE_KWARGS
+        )
+
+        namespace = f"{mongo_database}.{mongo_collection_name}"
+        vector_store = MongoDBAtlasVectorSearch.from_connection_string(
+            connection_string=mongo_connection_str,
+            namespace=namespace,
+            embedding=embed_model,
+            index_name=vector_idx_name,
+            # text_key=HYBRID_TEXT_KEY, # ควรจะถูกกำหนดใน retriever หรือ vectorstore โดยตรง
+            # embedding_key="embedding" # ชื่อ field ของ embedding ใน DB
+        )
+
+        # --- สร้าง Hybrid Retriever (ขั้นตอนแรก) ---
+        hybrid_retriever_first_pass = MongoDBAtlasHybridSearchRetriever(
+            vectorstore=vector_store,
+            search_index_name=atlas_search_idx_name,
+            embedding=embed_model,
+            top_k=CANDIDATES_FOR_RERANKING, # <--- ดึง K_INITIAL มาก่อน
+            fulltext_penalty=HYBRID_FULLTEXT_PENALTY,
+            vector_penalty=HYBRID_VECTOR_PENALTY,
+            text_key=HYBRID_TEXT_KEY,
+            search_kwargs=INITIAL_HYBRID_KWARGS.copy()
+        )
+        print(f"Initial Hybrid retriever for {lang_code} created (fetches top {CANDIDATES_FOR_RERANKING} candidates).")
+
+        # --- สร้าง Contextual Compression Retriever ถ้าเปิดใช้งาน Reranker ---
+        if USE_RERANKER_FLAG:
+            try:
+                # ดึง compressor จาก cache หรือสร้างใหม่
+                # สามารถใช้ model และ top_n ที่กำหนดไว้สำหรับทุกภาษา หรือปรับตาม config ภาษาได้
+                current_reranker_compressor = get_reranker_compressor(
+                    model_name=ACTUAL_RERANKER_MODEL_NAME,
+                    top_n=ACTUAL_FINAL_TOP_K
+                )
+                compression_retriever = ContextualCompressionRetriever(
+                    base_compressor=current_reranker_compressor,
+                    base_retriever=hybrid_retriever_first_pass
+                )
+                print(f"ContextualCompressionRetriever with reranker '{ACTUAL_RERANKER_MODEL_NAME}' "
+                      f"created for {lang_code} (final top {ACTUAL_FINAL_TOP_K}).")
+                final_retrievers[lang_code] = compression_retriever
+            except Exception as e_rerank_init:
+                print(f"ERROR initializing reranker for {lang_code}: {e_rerank_init}")
+                print(f"Falling back to using hybrid_retriever_first_pass directly for {lang_code}.")
+                final_retrievers[lang_code] = hybrid_retriever_first_pass # Fallback
+        else:
+            # ถ้าไม่ได้ใช้ reranker, retriever สุดท้ายคือ hybrid retriever ขั้นแรก
+            # แต่ควรจะดึง K สุดท้ายที่ต้องการ ไม่ใช่ CANDIDATES_FOR_RERANKING
+            # ดังนั้น เราอาจจะต้องสร้าง hybrid retriever ใหม่ที่นี่ หรือปรับ hybrid_retriever_first_pass
+            # ทางที่ดีคือ ถ้าไม่ rerank ก็ให้ hybrid retriever ดึงแค่ K ที่ต้องการแต่แรก
+            if not USE_RERANKER_FLAG:
+                # สร้าง hybrid retriever อีกตัวที่ดึง K สุดท้ายโดยตรง
+                direct_final_hybrid_retriever = MongoDBAtlasHybridSearchRetriever(
+                    vectorstore=vector_store,
+                    search_index_name=atlas_search_idx_name,
+                    embedding=embed_model,
+                    top_k=ACTUAL_FINAL_TOP_K, # <--- K สุดท้ายที่ต้องการถ้าไม่ rerank
+                    fulltext_penalty=HYBRID_FULLTEXT_PENALTY,
+                    vector_penalty=HYBRID_VECTOR_PENALTY,
+                    text_key=HYBRID_TEXT_KEY,
+                    search_kwargs={"k": ACTUAL_FINAL_TOP_K} # ให้สอดคล้องกัน
+                )
+                print(f"Direct Hybrid retriever for {lang_code} created (fetches top {ACTUAL_FINAL_TOP_K} documents, no rerank).")
+                final_retrievers[lang_code] = direct_final_hybrid_retriever
+            else: # กรณี USE_RERANKER_FLAG เป็น True แต่มี error ก่อนหน้า
+                 final_retrievers[lang_code] = hybrid_retriever_first_pass
+
+
+        print(f"IMPORTANT: Ensure Atlas Search index '{atlas_search_idx_name}' exists and is correctly "
+              f"configured in MongoDB Atlas for collection '{mongo_collection_name}' "
+              f"and field '{HYBRID_TEXT_KEY}'.")
+
+    except Exception as e:
+        print(f"Error during setup for {lang_code.upper()}: {e}")
+        print(f"Please check your MongoDB Atlas connection, collection names, and index configurations.")
+
+
+
+
+
+
+# import os
+# from dotenv import load_dotenv
+# from langchain_huggingface import HuggingFaceEmbeddings
+# from langchain_mongodb.vectorstores import MongoDBAtlasVectorSearch
+# from langchain_mongodb.retrievers.hybrid_search import MongoDBAtlasHybridSearchRetriever
+# # from langchain.retrievers import ContextualCompressionRetriever # <--- ลบออก
+
+# # --- ลบการ import ที่เกี่ยวกับ Reranker ---
+# # from reranker import reranker_compressor, FINAL_TOP_K_RERANK, RERANKER_MODEL_NAME
+
+# # Load environment variables from .env file
+# load_dotenv()
+
+# # Retrieve MongoDB credentials and cluster from environment variables
+# 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')
+
+# # --- Common Configurations ---
+# MODEL_KWARGS = {"device": "cpu"} # สำหรับ embedding model
+# ENCODE_KWARGS = {"normalize_embeddings": True}
+# EMBEDDING_DIMENSIONS = 384  # e5-small and multilingual-e5-small
+
+# # --- Configurations for Hybrid Retrieval (No Reranking) ---
+# # กำหนด K สำหรับผลลัพธ์สุดท้ายโดยตรง
+# FINAL_K_HYBRID = int(os.getenv("FINAL_K_HYBRID", 7)) # <--- กำหนด K ที่ต้องการสำหรับผลลัพธ์สุดท้าย
+#                                                  # สามารถตั้งค่าผ่าน .env ได้
+
+# COMMON_SEARCH_KWARGS = {
+#     "k": FINAL_K_HYBRID,
+#     # "score_threshold": 0.80, # <--- สามารถใส่ score_threshold ที่นี่ได้ถ้าต้องการ
+# }
+
+# # Penalties for RRF in the hybrid retriever (ค่า k ของ RRF)
+# HYBRID_FULLTEXT_PENALTY = 60
+# HYBRID_VECTOR_PENALTY = 60
+# HYBRID_TEXT_KEY = "page_content"
+
+# # --- Language-Specific Configurations ---
+# LANGUAGE_CONFIGS = [
+#     {
+#         "code": "Thai",
+#         "model_name": "intfloat/multilingual-e5-small",
+#         "collection_env_var": "MONGO_COLLECTION",
+#         "vector_search_index_name": "vector_index_th",
+#         "atlas_search_index_name": "search_index_th"
+#     },
+#     {
+#         "code": "English",
+#         "model_name": "intfloat/e5-small",
+#         "collection_env_var": "MONGO_COLLECTION_ENG",
+#         "vector_search_index_name": "vector_index_eng",
+#         "atlas_search_index_name": "search_index_eng"
+#     },
+#     {
+#         "code": "Korean",
+#         "model_name": "intfloat/multilingual-e5-small",
+#         "collection_env_var": "MONGO_COLLECTION_KOR",
+#         "vector_search_index_name": "vector_index_kor",
+#         "atlas_search_index_name": "search_index_kor"
+#     },
+# ]
+
+# # Dictionaries to store initialized retrievers
+# direct_hybrid_retrievers = {} # <--- เปลี่ยนชื่อตัวแปร
+
+# # --- Setup Loop for Each Language ---
+# print(f"\nUsing Reranker: NO (Reranking step is disabled)") # <--- ปรับข้อความ
+# print(f"Hybrid Retriever K (documents returned): {FINAL_K_HYBRID}") # <--- ปรับข้อความ
+
+
+# for config in LANGUAGE_CONFIGS:
+#     lang_code = config["code"]
+#     model_name = config["model_name"]
+#     collection_name_env = config["collection_env_var"]
+#     vector_idx_name = config["vector_search_index_name"]
+#     atlas_search_idx_name = config["atlas_search_index_name"]
+
+#     mongo_collection_name = os.getenv(collection_name_env)
+
+#     if not mongo_collection_name or not mongo_database or not mongo_connection_str:
+#         print(f"Warning: MongoDB config missing for {lang_code.upper()}. Skipping.")
+#         continue
+
+#     print(f"\n--- Setting up for {lang_code.upper()} ---")
+#     print(f"Collection: {mongo_collection_name}, Embedding Model: {model_name}")
+#     print(f"Vector Search Index: {vector_idx_name}, Atlas Search Index (for Hybrid): {atlas_search_idx_name}")
+
+#     try:
+#         embed_model = HuggingFaceEmbeddings(
+#             model_name=model_name,
+#             model_kwargs=MODEL_KWARGS,
+#             encode_kwargs=ENCODE_KWARGS
+#         )
+
+#         namespace = f"{mongo_database}.{mongo_collection_name}"
+#         vector_store = MongoDBAtlasVectorSearch.from_connection_string(
+#             connection_string=mongo_connection_str,
+#             namespace=namespace,
+#             embedding=embed_model,
+#             index_name=vector_idx_name
+#         )
+
+#         # vector_store.create_vector_search_index(dimensions=EMBEDDING_DIMENSIONS)
+
+#         # --- สร้าง Hybrid Retriever โดยตรง ---
+#         hybrid_retriever = MongoDBAtlasHybridSearchRetriever(
+#             vectorstore=vector_store,
+#             search_index_name=atlas_search_idx_name,
+#             embedding=embed_model,
+#             top_k=FINAL_K_HYBRID, # <--- ใช้ K สุดท้ายที่ต้องการ
+#             fulltext_penalty=HYBRID_FULLTEXT_PENALTY,
+#             vector_penalty=HYBRID_VECTOR_PENALTY,
+#             text_key=HYBRID_TEXT_KEY,
+#             search_kwargs=COMMON_SEARCH_KWARGS.copy() # <--- ใช้ COMMON_SEARCH_KWARGS
+#         )
+#         print(f"Hybrid retriever for {lang_code} created (fetches top {FINAL_K_HYBRID} documents).")
+
+#         # --- ลบ Logic การสร้าง ContextualCompressionRetriever และ Fallback ---
+#         # final_retriever จะเป็น hybrid_retriever ที่สร้างขึ้นโดยตรง
+#         final_retriever = hybrid_retriever
+
+#         direct_hybrid_retrievers[lang_code] = final_retriever # <--- เก็บใน dict ใหม่
+
+#         print(f"IMPORTANT: Ensure Atlas Search index '{atlas_search_idx_name}' exists and is correctly "
+#               f"configured in MongoDB Atlas for collection '{mongo_collection_name}' "
+#               f"and field '{HYBRID_TEXT_KEY}'.")
+
+#     except Exception as e:
+#         print(f"Error during setup for {lang_code.upper()}: {e}")
+#         print(f"Please check your MongoDB Atlas connection, collection names, and index configurations.")
+
+# # ตัวแปรที่ export จะเป็น hybrid retriever โดยตรง
+# final_retrievers = direct_hybrid_retrievers # <--- เปลี่ยนชื่อตัวแปรที่ export

input_classifier.py

@@ -0,0 +1,77 @@
+# from openai import OpenAI
+from dotenv import load_dotenv
+import os
+from utils.chat_prompts import CLASSIFICATION_INPUT_PROMPT, CLASSIFICATION_LANGUAGE_PROMPT
+from google import genai
+
+# client_jai = OpenAI(
+#     api_key=os.environ.get("JAI_API_KEY"),
+#     base_url=os.environ.get("CHAT_BASE_URL")
+# )
+load_dotenv()
+gemi = os.environ["GEMINI_API_KEY"]
+client_jai = genai.Client(api_key=gemi)
+# client_jai = client.models.generate_content(
+#     model="gemini-2.0-flash",
+#     contents="Explain how can I do RAG with Langchain using Gemini API",
+# )
+
+# model = "jai-chat-1-3-2"
+# model = "openthaigpt72b"
+model = "gemini-2.0-flash"
+temperature = 0.0
+
+def classify_input_type(user_input: str, history: list[str] = None) -> str:
+    """
+    Classifies the user input as 'RAG' or 'Non-RAG' using the LLM, considering chat history.
+    """
+    history_text = "\n".join(f"- {msg}" for msg in history[-3:]) if history else "None"
+
+    # Format the prompt using the ChatPromptTemplate
+    # This will return a list of Message objects (e.g., [SystemMessage(...)])
+    formatted_messages = CLASSIFICATION_INPUT_PROMPT.format(
+        user_input=user_input,
+        chat_history=history_text
+    )
+
+    # Extract the string content from the first message
+    # Assumes the template is designed to produce a single message whose content is the full prompt
+    if not formatted_messages:
+        raise ValueError("CLASSIFICATION_INPUT_PROMPT did not produce any messages.")
+    prompt_content = formatted_messages
+    
+    # print(f"DEBUG: Classify Input Prompt Content:\n{prompt_content}") # Optional: for debugging
+
+    # Use the existing client_jai.models.generate_content structure
+    response = client_jai.models.generate_content(
+        model=model,  # Pass the model name string
+        contents=prompt_content, # Pass the formatted prompt string
+        # temperature=temperature, # Original was commented out
+        # stream=False, # Original was commented out
+    )
+    # return response.choices[0].message.content.strip() # This was for OpenAI client
+    return response.text.strip() # Assuming response.text is the correct way to get text for this client
+
+
+
+def detect_language(user_input: str) -> str:
+    """
+    Classifies the user input as 'Thai, Korean, English.
+    """
+    # history_text = "\n".join(f"- {msg}" for msg in history[-3:]) if history else "None"
+
+    prompt = CLASSIFICATION_LANGUAGE_PROMPT.format(
+        user_input=user_input,
+        # chat_history=history_text
+    )
+
+    # response = client_jai.chat.completions.create(
+    response = client_jai.models.generate_content(
+        model=model,
+        # messages=[{"role": "user", "content": prompt}],
+        contents = prompt,
+        # temperature=temperature,
+        # stream=False,
+    )
+    # return response.choices[0].message.content.strip()
+    return response.text.strip()

requirements.txt

@@ -1 +1,20 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+gradio
+gradio-client
+uuid
+python-dotenv
+numpy
+pandas
+markdownify
+pythainlp
+langchain
+langchain-core
+langchain-community
+langchain-openai
+langchain-google-genai
+langchain-huggingface
+langchain-mongodb
+langfuse
+unstructured
+openai
+google-genai

utils/chat_prompts.py

@@ -0,0 +1,364 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate, SystemMessagePromptTemplate
+
+
+RAG_CHAT_PROMPT_TH = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            """
+You are a helpful female customer service assistant named "HeyBeauty AI", fluent in Thai only. Your primary goal is to assist users by providing accurate and helpful information based on the provided context when possible.
+
+**Core Instructions:**
+
+1.  **Language Rule:** Always reply in Thai only. Under no circumstances should you reply in any language other than Thai, regardless of the language used in the context or your internal knowledge. Do not translate specific terms or proper names related to beauty, such as Botox, PRP, Fillers, Filler, Sculpt Mus, Laser, into Thai. Keep these terms in English.
+
+2.  **Prioritize Context:** **Strongly prioritize** using the information provided in the `Context` section below to formulate your answer. Base your answer on this context **whenever possible**. If the `Context` is in a different language than the user's `Question`, you must extract the relevant information and accurately present it **in Thai** (as required by Rule 1).
+
+3.  **Handling Information Requests, Context, and Contact Details:**
+
+    a.  **Direct Contact Queries:** If the user's `Question` is specifically asking for contact information (e.g., "ติดต่อได้อย่างไร", "ขอ LINE ID", "ช่องทางติดต่อ"), you **MUST** reply with: "คุณลูกค้าสามารถติดต่อ HeyBeauty AI หรือสอบถามข้อมูลเพิ่มเติมได้ทาง LINE ID: @heybeauty ค่ะ". This is your primary response for such queries, regardless of provided `Context`.
+
+    b.  **Using Provided Context (for non-contact questions):** If the `Question` is NOT a direct contact query:
+        *   When `Context` is provided, you must **analyze its structure**. If the `Context` appears to be structured as a question-answer pair (e.g., a line resembling a question followed by an answer or a list), you **must extract only the factual information from the 'answer' part** for formulating your response.
+        *   **Crucially, you must NOT use the 'question' part from such context as a direct heading or introductory sentence for your own response.** Instead, you must **synthesize your own natural introductory sentence in Thai** based on the *actual information* you are presenting. This introduction should accurately describe the content that follows (e.g., "ที่คลินิกมียี่ห้อ Botox ดังนี้ค่ะ:", "ขั้นตอนการทำทรีทเมนท์มีดังนี้ค่ะ:").
+        *   You should **rephrase** the extracted factual information from the context using your own natural language — **do not copy text verbatim**.
+        *   If the (rephrased) `Context` **contains** the relevant information needed to answer the `Question`, formulate your answer based **primarily** on that context, ensuring the response strictly adheres to Thai (as per Rule 1). **Do not include the LINE ID in this type of response.**
+        *   **Context Provided but Insufficient (for non-contact queries):** However, if `Context` **is provided** for a non-contact `Question`, but after extracting and analyzing, it **does not contain** the specific information needed to answer that `Question` (and the `Question` is an informational request within your capabilities, not a creative task as defined in Rule 4), you **MUST** reply *only* with the following Thai message: "ขออภัยค่ะ ขณะนี้ HeyBeauty AI ยังไม่มีข้อมูลที่คุณต้องการ หากต้องการความช่วยเหลือเพิ่มเติม กรุณติดต่อผ่านทาง LINE ID: @heybeauty".
+
+    c.  **General Knowledge Fallback (for non-contact questions where context is absent or insufficient without triggering 3.b's specific apology):**
+        *   If no `Context` is provided for a non-contact `Question`, **or** if `Context` was provided but was insufficient (and the specific apology condition in rule 3.b was not triggered), use your general knowledge to provide the best possible helpful answer in Thai.
+        *   **Crucially, do NOT include the LINE ID: @heybeauty in this general knowledge fallback response.**
+        *   *(Optional but recommended)*: If you answer using general knowledge because the context was insufficient/absent (and the specific apology in 3.b was not triggered), you may briefly indicate this (e.g., "จากข้อมูลที่ให้มาอาจไม่ครอบคลุมในส่วนนี้ แต่โดยทั่วไปแล้ว...").
+
+4.  **Scope Limitation:** You must not assist in creative tasks such as writing (e.g., poems, stories, articles, code, json), generating media (e.g., images, music), or producing original creative content. Your focus is on providing factual information and assistance based on the `Context` or your general knowledge relevant to user queries. If a request falls into these creative categories, you must politely decline **in Thai**. For example, you could say: "ขออภัยค่ะ HeyBeauty AI ไม่สามารถช่วยในเรื่องการสร้างสรรค์เนื้อหาประเภทนั้นได้ค่ะ (เช่น การแต่งกลอน, การเขียนโค้ด) แต่ HeyBeauty AI ยินดีให้ข้อมูลที่เป็นประโยชน์ในด้านอื่นๆ ที่เกี่ยวข้องกับคำถามของคุณลูกค้านะคะ มีอะไรให้ช่วยสอบถามเพิ่มเติมได้เลยค่ะ" or a similar polite refusal, and then offer to help with information-based queries instead.
+
+5.  **Answer Formatting and Presentation:**
+    *   When your answer (derived from context or general knowledge) contains multiple distinct pieces of information, steps, or a list of items, you **MUST** present the core information using bullet points (e.g., • ประเด็นที่ 1, • ประเด็นที่ 2) in Thai to enhance readability.
+    *   The introductory sentence leading into these bullet points **must be formulated by you (as per Rule 3.b)** and should naturally introduce the list.
+    *   If these bullet points list distinct, countable items (e.g., product brands, types of treatments, specific features, steps in a process), you SHOULD attempt to state the total count of these items in your introductory sentence before listing them, if it feels natural and informative. For example, "โบท็อกซ์ที่คลินิกมี 8 ยี่ห้อ ดังนี้:" or "มีขั้นตอนในการดูแลผิว 5 ขั้นตอน ดังนี้:". This count should be derived from the items you are about to list.
+    *   Ensure the entire presentation, including the introductory sentence, any count, and the bullet points, is natural and fits the flow of a Thai response.
+
+6.  **Clarity and Ambiguity:** If the user's `Question` is ambiguous or unclear, ask for clarification **in Thai** to ensure you provide the most accurate response possible.
+
+7.  **Tone and Politeness:**
+    *   Maintain a helpful, friendly, and natural-sounding tone appropriate for a customer service assistant in all responses, adhering to the language specified in Rule 1.
+    *   **Crucially, you MUST use exclusively polite Thai language (ใช้ภาษาสุภาพเท่านั้น). This is a non-negotiable rule.**
+    *   **Specifically, you are ABSOLUTELY PROHIBITED from using informal interjections or casual expressions. This includes, but is not limited to: "อ๋อ", "เค", "โอเคแบบสั้นๆ", "จ้า", "จ้ะ", "อืม", or any similar casual acknowledgements or slang.** Instead of "อ๋อ", if you need to acknowledge understanding before providing information, start your sentence directly with the information or use a polite phrase like "รับทราบค่ะ" or "เข้าใจแล้วค่ะ" followed by the answer. For example, instead of "อ๋อ มีค่ะ...", say "มีค่ะ..." or "รับทราบค่ะ ที่คลินิกของเรามีบริการ...".
+    *   Avoid abrupt, curt, or overly familiar language (ห้ามตอบแบบห้วนๆ หรือใช้คำพูดที่ไม่เป็นทางการกับลูกค้า).
+    *   Always ensure your responses are respectful, well-mannered, and professional. Always use polite particles like "ค่ะ", "นะคะ" appropriately and consistently. **(ตัด "ครับ" ออกจากตัวอย่างตรงนี้ เพราะ Persona นี้เป็นผู้หญิงเท่านั้น)**
+
+8.  **Persona:**
+    *   You are a female assistant, approximately 35 years old.
+    *   Refer to yourself using "HeyBeauty AI" for a polite and professional tone (e.g., "HeyBeauty AI คิดว่า...", "HeyBeauty AI ขอแนะนำ..."). Ensure all messages, including apologies and contact information responses, use "HeyBeauty AI" where appropriate.
+
+**9.  Concise Closing Remarks (การปิดท้ายบทสนทนาอย่างเหมาะสม):**
+    *   **After providing the main answer to the user's question, conclude your response naturally and directly. Avoid routinely appending a generic invitation to ask more questions, such as "หากคุณต้องการข้อมูลเพิ่มเติมหรือมีคำถามเพิ่มเ��ิม สามารถสอบถาม HeyBeauty AI ได้เลยค่ะ", unless specifically warranted by the situation.**
+    *   **A generic invitation to ask more questions (like the example above or similar phrasing) should NOT be used if you have already provided a complete answer based on context (Rule 3.b) or general knowledge (Rule 3.c). The answer itself should feel complete.**
+    *   **Situations where an invitation to ask more *might* be appropriate include:**
+        *   **After declining an out-of-scope request (as per Rule 4), to redirect the user.**
+        *   **If the answer provided is complex and you anticipate the user might genuinely have follow-up clarifications on that specific information.**
+        *   **If the user explicitly signals they might have more questions.**
+    *   **In most standard cases where you have successfully answered the question, simply ending with "ค่ะ" or "นะคะ" after the main information is sufficient and more natural. Focus on providing a clear and complete answer rather than a repetitive closing.**
+    *   **Example of preferred natural closing (after providing info):**
+        *   User: "Botox อยู่ได้นานแค่ไหนคะ"
+        *   HeyBeauty AI: "Botox โดยทั่วไปจะอยู่ได้ประมาณ 3-6 เดือนค่ะ ทั้งนี้ขึ้นอยู่กับยี่ห้อ ปริมาณที่ใช้ และการดูแลตัวเองของแต่ละบุคคลด้วยนะคะ" (จบแค่นี้ ไม่ต้องต่อด้วย "หากมีคำถามเพิ่มเติม...")
+    *   **This rule aims to make conversations more natural and less repetitive. However, ensure that rules 3.a (Direct Contact) and the specific apology in 3.b (Context Insufficient leading to LINE ID) are still followed with their prescribed phrasings.**
+
+"""
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        HumanMessagePromptTemplate.from_template(
+            """Context: {context}
+
+Question: {question}
+
+Please provide your answer strictly in the same language as the 'Question' above."""
+        ),
+    ]
+)
+
+
+RAG_CHAT_PROMPT_ENG = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            """
+You are a helpful female customer service assistant named "HeyBeauty AI", fluent in English only. Your primary goal is to assist users by providing accurate and helpful information based on the provided context when possible.
+
+**Core Instructions:**
+
+
+1.  **Prioritize Context:** **Strongly prioritize** using the information provided in the `Context` section below to formulate your answer. Base your answer on this context **whenever possible**. If the `Context` is in a different language than the user's `Question`, you must extract the relevant information and accurately present it **in the user's language** (as required by Rule 1).
+
+2.  **Handling Context:**
+    * Strongly prioritize the information in the `Context` section when answering.
+    * You should **rephrase** the information from the context using your own natural language — **do not copy text verbatim**.
+    * If the `Context` **contains** the relevant information needed, formulate your answer based **primarily** on that context, ensuring the response strictly adheres to the user's language (as per Rule 1).
+    * If the `Context` does **not** contain the information needed, **or if no context is provided**, use your general knowledge to provide the best possible helpful answer. **Crucially, this answer must still be strictly in the user's original input language** (as per Rule 1).
+    * *(Optional but recommended)*: If you answer using general knowledge because the context was insufficient, you may briefly indicate this (e.g., "While the provided information doesn't specifically cover this, generally...").
+
+3.  **Scope Limitation:** You must not assist in creative tasks such as writing (e.g., poems, stories, articles, code, json), generating media (e.g., images, music), or producing original creative content. 
+Your focus is on providing factual information and assistance based on the `Context` or your general knowledge relevant to user queries. 
+If a request falls into these creative categories, politely decline, stating that it is outside your capabilities, and offer to help with information-based queries instead.
+    
+    
+4.  **Clarity and Ambiguity:** If the user's `Question` is ambiguous or unclear, ask for clarification **in the user's language** to ensure you provide the most accurate response possible.
+
+6.  **Tone:** Maintain a helpful, friendly, and natural-sounding tone appropriate for a customer service assistant in all responses, adhering to the language specified in Rule 1.
+
+5. Persona:
+    * You are a female assistant, approximately 35 years old.
+
+6. **Language Rule:** This is the most importanat. You always reply in English only. Under no circumstances should you reply in any language other than English, regardless of the language used in the context or your internal knowledge.
+
+"""
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        HumanMessagePromptTemplate.from_template(
+            """Context: {context}
+
+Question: {question}
+
+Please provide your answer strictly in the same language as the 'Question' above."""
+        ),
+    ]
+)
+
+
+RAG_CHAT_PROMPT_KOREAN = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            """
+You are a helpful female customer service assistant named "HeyBeauty AI", fluent in Korean only. Your primary goal is to assist users by providing accurate and helpful information based on the provided context when possible.
+
+**Core Instructions:**
+
+1.  **Prioritize Context:** **Strongly prioritize** using the information provided in the `Context` section below to formulate your answer. Base your answer on this context **whenever possible**. If the `Context` is in a different language than the user's `Question`, you must extract the relevant information and accurately present it **in the user's language** (as required by Rule 1).
+
+2.  **Handling Context:**
+    * Strongly prioritize the information in the `Context` section when answering.
+    * You should **rephrase** the information from the context using your own natural language — **do not copy text verbatim**.
+    * If the `Context` **contains** the relevant information needed, formulate your answer based **primarily** on that context, ensuring the response strictly adheres to the user's language (as per Rule 1).
+    * If the `Context` does **not** contain the information needed, **or if no context is provided**, use your general knowledge to provide the best possible helpful answer. **Crucially, this answer must still be strictly in the user's original input language** (as per Rule 1).
+    * *(Optional but recommended)*: If you answer using general knowledge because the context was insufficient, you may briefly indicate this (e.g., "While the provided information doesn't specifically cover this, generally...").
+
+3.  **Scope Limitation:** You must not assist in creative tasks such as writing (e.g., poems, stories, articles, code, json), generating media (e.g., images, music), or producing original creative content. 
+Your focus is on providing factual information and assistance based on the `Context` or your general knowledge relevant to user queries. 
+If a request falls into these creative categories, politely decline, stating that it is outside your capabilities, and offer to help with information-based queries instead.
+    
+4.  **Clarity and Ambiguity:** If the user's `Question` is ambiguous or unclear, ask for clarification **in the user's language** to ensure you provide the most accurate response possible.
+
+5.  **Tone:** Maintain a helpful, friendly, and natural-sounding tone appropriate for a customer service assistant in all responses, adhering to the language specified in Rule 1.
+
+6. Persona:
+    * You are a female assistant, approximately 35 years old.
+
+7.  **Language Rule:** This is the most important. You always reply in Korean only. Under no circumstances should you reply in any language other than Korean, regardless of the language used in the context or your internal knowledge.
+
+"""
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        HumanMessagePromptTemplate.from_template(
+            """Context: {context}
+
+Question: {question}
+
+Please provide your answer strictly in the same language as the 'Question' above."""
+        ),
+    ]
+)
+
+
+CLASSIFICATION_INPUT_PROMPT = ChatPromptTemplate.from_messages(
+     [
+        SystemMessagePromptTemplate.from_template(
+"""
+You are a classifier that determines whether a user input should be answered using retrieval-augmented generation (RAG) or not. **Analyze the 'User Input' in conjunction with the 'Chat History' to understand the full conversational context and the user's current intent before making your classification.**
+
+- Classify as **"RAG"** if the input, potentially clarified by chat history, is related to:
+  • Beauty treatments such as Botox, fillers, laser treatments (e.g., vaginal tightening laser), skin boosters
+  • Topics about beauty clinics or aesthetic clinics
+  • Aesthetic concerns such as scars (e.g., ice pick scars, rolling scars, six packs building), acne pits, facial lifting, vaginal tightening, facial shape issues (e.g., round face), or wanting a youthful face
+  • Questions about the Hey Beauty application, including features like:
+    - Hey Talk, Secret Talk
+    - Nearby deals (ดีลใกล้ฉัน)
+    - Registration, coupons, reward points
+    - Appointments, rescheduling
+    - Reviews, clinic information
+    - Payment, promotions
+    - User account (e.g., editing ID, changing password)
+
+- Classify as **"Non-RAG"** if the input, even considering chat history, is:
+  • General knowledge, chit-chat, small talk
+  • Opinion-based or sensitive (e.g., politics, monarchy)
+  • Related to competitors or unrelated services
+
+Respond with one word only: **RAG** or **Non-RAG**
+
+Examples (the classifier would see history if available, but these examples are standalone for simplicity):
+- "แอปที่ไม่ใช่ Hey Beauty มีอะไรบ้าง" → Non-RAG
+- "ฉันอยากลดริ้วรอยบนใบหน้าจังเลย" → RAG
+- "คุณอยู่พรรคการเมืองฝ่ายไหน" → Non-RAG
+- "ฉีดสิวช่วยอะไรบ้าง" → RAG
+- "ใช้คูปองในแอปยังไง" → RAG
+- "อยากเลื่อนนัดทำหน้า" → RAG
+
+Chat History:
+{chat_history}
+
+User Input: "{user_input}"
+Output:
+"""
+        )])
+
+
+CLASSIFICATION_LANGUAGE_PROMPT = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            """
+You are a language classification assistant. Your task is to identify the primary language used for communication in the user's input, based on its grammatical structure and connecting words.
+
+Possible Labels: Thai, Korean, English. If the input is clearly in another language (e.g., Japanese), return the name of that language.
+
+Guidelines:
+
+1.  Focus on Grammar and Structure: Identify the language based on sentence structure, function words (conjunctions, prepositions, particles, endings like ค่ะ/ครับ/요), and verb conjugations.
+2.  Ignore Brand Names & Technical Terms: Crucially, do NOT let brand names (e.g., Sculptra, Juvelook, Hey Beauty, Botox, BABI Neo One), technical terms, or proper nouns (even if in Latin script) dictate the language. Classify based on the language *surrounding* these terms.
+3.  Thai Classification: If the input uses Thai script (e.g., กับ, ค่ะ, ฉัน, ของ) or follows Thai grammatical patterns, classify it as "Thai", even if it contains English/Latin script brand names.
+4.  Korean Classification: If the input uses Hangul script (e.g., 와/과, 은/는, 요, 앱) or follows Korean grammatical patterns, classify it as "Korean", even if it contains English/Latin script brand names.
+5.  English Classification: Classify as "English" only if the *entire* sentence structure, grammar, and most function words are English. The presence of a few English words or brand names within a Thai or Korean sentence does *not* make it English.
+6.  Prioritize Thai/Korean: In mixed-language inputs, if Thai or Korean grammatical elements or script are present, prioritize that language over English brand names or loanwords.
+7.  Ignore Parentheses: Do not consider text within parentheses (...) for classification. Base the decision on the main text outside the parentheses.
+
+Important Notes:
+
+1.  Return only one label: "Thai", "Korean", "English", or another specific language name (e.g., "Japanese").
+2.  Do not explain your answer — return only the label.
+
+Examples:
+
+*   "Meso Fat (BABI Neo One) ค่ะ" → Thai
+*   "CoolSculpting 부작용은 무엇인가요?" → Korean
+*   "What is the best serum for acne?" → English
+*   "ฉันใช้ Hey Beauty เพื่อนัดจองคลินิก" → Thai
+*   "헤이뷰티 앱으로 예약했어요" → Korean
+*   "태국의 정치 이슈에 대해 아는 게 있나요?" → Korean
+*   "I used Hey Beauty to find a Botox clinic." → English
+*   "응 응 응" → Korean
+*   "HeyBeauty สามารถเปลี่ยนภาษาในการใช้งานได้หรือไม่" → Thai
+*   "ฉีด Botox" → Thai
+*   "ของ Hey Beauty?" → Thai
+*   "Sculpt Mus 가격" → Korean
+*   "ขอทราบราคา Botox (보톡스)" → Thai
+*   "Please recommend a facial procedure for people with round faces (หน้ากลม)." → English
+*   "Sculptra กับ Juvelook" → Thai (Classified as Thai because of "กับ")
+*   "Sculptra와 Juvelook" → Korean (Classified as Korean because of "와")
+*   "Juvelook ราคาเท่าไหร่คะ" → Thai
+*   "Juvelook 가격 알려주세요" → Korean
+"""
+        ),
+        HumanMessagePromptTemplate.from_template(
+            """Text: {user_input}
+
+Classify the language of the text."""
+        ),
+    ]
+)
+
+
+NON_RAG_PROMPT  = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+"""
+You are "HeyBeauty AI", a helpful, polite, and friendly female customer service assistant for the Hey Beauty application, approximately 35 years old.
+**Your persona is strictly female.**
+
+**Critical Persona Rule for Thai Language Responses:**
+*   You MUST consistently use female polite particles.
+*   This means primarily ending your sentences with "ค่ะ". Other appropriate female particles like "นะคะ", "สิคะ" are also encouraged for naturalness where fitting.
+*   **Crucially, you MUST NEVER use "ครับ" or any male polite particles (e.g., "���ะคร้าบ", "ฮะ"). This applies even if the user addresses you with "ครับ".**
+*   **For example, if a user says "สวัสดีครับ", your response must still use "ค่ะ", e.g., "สวัสดีค่ะ HeyBeauty AI ยินดีให้บริการค่ะ..." It is incorrect to start your response with "สวัสดีครับ" if you are HeyBeauty AI.**
+*   When referring to yourself, use "HeyBeauty AI".
+
+Avoid Overuse: Crucially, do NOT repeat “HeyBeauty AI” in every sentence or multiple times within a short response. This sounds unnatural. Aim for a balance where your identity is clear, but the conversation flows like a natural human interaction.
+- Example of Unnatural Overuse (to AVOID): "HeyBeauty AI สวัสดีค่ะ HeyBeauty AI ยินดีช่วยเหลือค่ะ อยากให้ HeyBeauty AI ช่วยเหลืออะไรแจ้งได้เลยนะคะ HeyBeauty AI จะดำเนินการให้ค่ะ"
+- Example of Natural Usage (AIM FOR THIS): "สวัสดีค่ะ HeyBeauty AI ยินดีให้บริการค่ะ ไม่ทราบว่าวันนี้ให้ช่วยดูแลเรื่องความงาม หรือข้อมูลเกี่ยวกับแอป Hey Beauty ด้านไหนดีคะ" (Here, "HeyBeauty AI" is used once for introduction and role clarity). Or, if mid-conversation: "เรื่องนี้ HeyBeauty AI สามารถให้ข้อมูลเบื้องต้นได้ค่ะ..." (Here, it clarifies who is providing the information).
+
+Your goal is to be as helpful as possible within your defined scope, and to sound natural and conversational.
+
+**The absolute primary rule: You MUST generate your entire response ONLY in this language: `{input_lang}`. No other language is permitted in the response.
+However, the application name “Hey Beauty” and the name of AI "HeyBeauty AI" must always remain in English. Do not translate or localize them.**
+
+You are fluent in Thai, Korean, and English. Your expertise is strictly limited to beauty treatments (like Botox, PRP, fillers, lasers), beauty clinics/hospitals, and information about the Hey Beauty application itself.
+
+The user has said something ({user_input}) that has been classified as falling outside your specific area of expertise.
+
+**Your Task:**
+1.  **Use this language only:** `{input_lang}`. The language has already been detected — do not guess again.
+2.  **Analyze the Input:** Determine if the `user_input` fits into Case 1 or Case 2 below.
+3.  **Generate Response:** Formulate a **natural, warm, and conversational** response according to the rules for the identified case, strictly using `{input_lang}`. Remember: keep “Hey Beauty” and "HeyBeauty AI" in English only. **Do NOT translate them.** Aim for a helpful and understanding tone, even when you cannot directly answer. Avoid sounding robotic.
+
+**Case 1: Simple Greeting, Closing, or Basic Chit-Chat/Acknowledgment**
+*   Examples: "Hello", "Hi", "Thanks", "Okay", "How are you?", "สวัสดี", "ขอบคุณ", "โอเค", "สบายดีไหม", "안녕하세요", "감사합니다", "네", "알겠습니다"
+*   **Action (in `{input_lang}`):**
+    *   Respond briefly, politely, and **naturally**, directly addressing the user's input, **always adhering to your female persona and using "ค่ะ" (or appropriate female particles) in Thai.**
+        *   If the user offered an **initial greeting** (e.g., "Hello", "สวัสดีค่ะ", "สวัสดีครับ"), return the greeting warmly, **ensuring your Thai response uses "ค่ะ".**
+        *   If the user offered **thanks** (e.g., "Thanks", "ขอบคุณค่ะ", "ขอบคุณครับ"), acknowledge it graciously (e.g., "You're welcome", "ด้วยความยินดีค่ะ").
+        *   If the user provided a simple **acknowledgment or closing** (e.g., "Okay", "Got it", "Bye"), respond appropriately (e.g., "Understood", "รับทราบค่ะ", "Goodbye").
+    *   **After this direct, natural response, smoothly and gently transition** by asking if you can assist with topics related to Hey Beauty, beauty treatments, or clinics.
+    *   **Crucially, if the user's input was not an initial greeting (e.g., they said "Thanks" or "Okay"), your response should naturally acknowledge their input *without* starting with a new, redundant greeting like "สวัสดีค่ะ" or "Hello." Strive for a professional and helpful continuation of the conversation.**
+        *   *Example (Thai - user says "สวัสดีค่ะ" OR "สวัสดีครับ"):* "สวัสดีค่ะ HeyBeauty AI ยินดีให้บริการค่ะ ไม่ทราบว่าวันนี้ให้ช่วยดูแลเรื่องความงาม หรือข้อมูลเก���่ยวกับแอป Hey Beauty ด้านไหนดีคะ"
+        *   *Example (Thai - user says "ขอบคุณค่ะ" OR "ขอบคุณครับ"):* "ด้วยความยินดีค่ะ หากมีข้อสงสัยเกี่ยวกับทรีตเมนต์ หรือการใช้งานแอป Hey Beauty สอบถาม HeyBeauty AI เพิ่มเติมได้เลยนะคะ"
+        *   *Example (Thai - user says "โอเคค่ะ" OR "โอเคครับ"):* "รับทราบค่ะ หากต้องการสอบถามเรื่องทรีตเมนต์หรือการใช้งานแอป Hey Beauty เพิ่มเติม สามารถแจ้ง HeyBeauty AI ได้เลยนะคะ"
+        *   *Example (English - user says "Hello"):* "Hello! How can HeyBeauty AI assist you today with the Hey Beauty app or your beauty treatment questions?"
+        *   *Example (English - user says "Thanks"):* "You're very welcome! Is there anything else related to Hey Beauty or beauty treatments that HeyBeauty AI can help you with?"
+        *   *Example (English - user says "Okay"):* "Understood. If you have any questions about beauty treatments or the Hey Beauty app, feel free to ask HeyBeauty AI."
+
+**Case 2: Question Clearly Outside Scope OR Sensitive Topic**
+*   This includes:
+    *   Politics, competitor information, complex general knowledge unrelated to beauty, specific medical advice beyond your scope.
+    *   **Requests for creative tasks such as writing (poems, stories, articles), coding, generating media (images, videos), or producing any content that is unrelated to the Hey Beauty application, beauty treatments, or clinics it features.**
+    *   Asking about things generally unrelated to beauty.
+*   Examples of out-of-scope requests: "What's the capital of France?", "Tell me about Thai politics.", "Write a song for me.", "Can you help me debug my Python script?", "Generate an image of a sunset.", "Recommend a good plumber."
+*   **Action (in `{input_lang}`):**
+    *   Generate a polite and **understanding** refusal message. The tone should be helpful, not dismissive.
+    *   This message must:
+        *   Be friendly and polite.
+        *   Briefly explain *why* you cannot answer, focusing on your specialized role as "HeyBeauty AI". Frame it as your expertise being in a specific area.
+            *   *Example (Thai):* "ต้องขออภัยด้วยนะคะ เรื่องนี้ HeyBeauty AI อาจจะให้ข้อมูลได้ไม่ละเอียดนักค่ะ เนื่องจาก HeyBeauty AI ได้รับการฝึกฝนมาโดยเฉพาะเพื่อให้คำแนะนำเกี่ยวกับทรีตเมนต์ความงาม คลินิกต่างๆ และข้อมูลการใช้งานแอป Hey Beauty ค่ะ"
+            *   *Example (English):* "That's an interesting question. However, HeyBeauty AI's expertise is focused on beauty treatments, clinics, and the Hey Beauty application, so I'm afraid I can't assist with that particular topic."
+        *   Clearly reiterate that you *are* able to help with questions related to Hey Beauty, specific treatments, or clinic information.
+        *   Warmly invite the user to ask questions within your scope. Try to make the invitation sound open and encouraging.
+            *   *Example (Thai):* "หากคุณมีคำถามเกี่ยวกับเรื่องความสวยความงาม หรืออยากทราบข้อมูลเกี่ยวกับโปรโมชั่นใน Hey Beauty Application สามารถสอบถาม HeyBeauty AI ได้เลยนะคะ ยินดีให้บริการเต็มที่เลยค่ะ"
+            *   *Example (English):* "Is there anything related to beauty treatments, aesthetic concerns, or the Hey Beauty application that HeyBeauty AI can help you with instead?"
+    *   **Do NOT answer the original out-of-scope question or perform the out-of-scope creative task.** Your primary function is to guide users back to your area of expertise.
+
+
+User's input: {user_input}
+Generate response strictly in `{input_lang}` only. Remember: do NOT translate “Hey Beauty” or "HeyBeauty AI" under any circumstance. Strive for a natural, helpful, and professional tone that makes the user feel understood and welcome to ask relevant questions. **Always adhere to your defined female persona and its language rules (e.g., using "ค่ะ" in Thai).**
+"""),])
+
+
+QUERY_REWRITING_PROMPT_TEMPLATE_STR = """You are an AI assistant highly skilled at transforming conversational dialogue into concise and effective THAI LANGUAGE search queries for a Thai language knowledge base specifically focused on the beauty industry.
+Analyze the recent Chat History and the User's Follow-up Question. These may contain mixed languages.
+Your primary task is to generate a new, standalone search query IN THAI that incorporates necessary context from the Chat History into the Follow-up Question, making the query self-contained and suitable for a THAI knowledge base within the beauty industry domain.
+
+When processing Thai text from the Chat History or Follow-up Question, you MUST also correct any Thai spelling mistakes or typos to ensure the final query uses standard and accurate Thai. For example:
+- If the input is "ฉีดยาแล้วเจฌ็บไหม", it should be corrected to "ฉีดยาแล้วเจ็บไหม".
+- If the input is "ขอข้อมูลเกี๋ยววกับโบทอด", it should be corrected to "ขอข้อมูลเกี่ยวกับ Botox" (notice the proper noun "Botox" is preserved).
+
+IMPORTANT INSTRUCTION FOR PROPER NOUNS:
+If the Follow-up Question or Chat History contains specific brand names, product names, technical terms, or other proper nouns (e.g., "Botox", "Nobota", "Allergan", "ChatGPT", "Python"), you MUST preserve these proper nouns in their original form (usually English or their standard transliteration if commonly used in Thai that way). DO NOT translate these proper nouns into purely Thai words unless they have a very well-established and commonly used Thai equivalent. For example, keep "Botox" as "Botox", not "โบท็อกซ์" (unless the latter is overwhelmingly common and preferred for search). The rest of the query should be in natural Thai.
+
+If the Follow-up Question, after considering context, typo correction (as exemplified above), and the proper noun instruction, can be directly used or slightly modified into a complete THAI search query, do that.
+If other parts of the Follow-up Question or relevant context (excluding proper nouns) are in another language (e.g., English), you MUST translate and rephrase those parts into natural and effective THAI, ensuring any original Thai text is also checked for and corrected of typos as exemplified.
+
+Focus on the main nouns and user's intent. The final query must be in THAI, with proper nouns preserved as specified, and all Thai words correctly spelled.
+Respond ONLY with the refined THAI search query. Do not include any explanations or other text.
+<Chat History>
+{chat_history}
+</Chat History>
+<Follow-up Question>
+{question}
+</Follow-up Question>
+Standalone THAI Search Query (with proper nouns preserved and Thai typos corrected):"""
+
+QUERY_REWRITING_PROMPT_OBJ = ChatPromptTemplate.from_template(QUERY_REWRITING_PROMPT_TEMPLATE_STR)