Update main.py

main.py

@@ -1,361 +1,158 @@
-# import os  
-# import shutil  
-# from flask import Flask, render_template, request, jsonify  
-# from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings  
-# from llama_index.llms.huggingface import HuggingFaceInferenceAPI  
-# from llama_index.embeddings.huggingface import HuggingFaceEmbedding  
-# from huggingface_hub import InferenceClient  
-# from transformers import AutoTokenizer, AutoModel
-# from deep_translator import GoogleTranslator
-# from transformers import AutoModelForCausalLM, AutoTokenizer
-# import torch
-# from accelerate import infer_auto_device_map
+import os  
+import shutil  
+from flask import Flask, render_template, request, jsonify  
+from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings  
+from llama_index.llms.huggingface import HuggingFaceInferenceAPI  
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding  
+from huggingface_hub import InferenceClient  
+from transformers import AutoTokenizer, AutoModel
+from deep_translator import GoogleTranslator
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+from accelerate import infer_auto_device_map
 
 
 
-# # Ensure HF_TOKEN is set  
-# HF_TOKEN = os.getenv("HF_TOKEN")  
-# if not HF_TOKEN:  
-#     raise ValueError("HF_TOKEN environment variable not set.")  
+# Ensure HF_TOKEN is set  
+HF_TOKEN = os.getenv("HF_TOKEN")  
+if not HF_TOKEN:  
+    raise ValueError("HF_TOKEN environment variable not set.")  
 
-# # repo_id = "meta-llama/Meta-Llama-3-8B-Instruct" 
-# repo_id = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
-# llm_client = InferenceClient(  
-#     model=repo_id,  
+# repo_id = "meta-llama/Meta-Llama-3-8B-Instruct" 
+repo_id = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+llm_client = InferenceClient(  
+    model=repo_id,  
+    token=HF_TOKEN,  
+)  
+
+# # Configure Llama index settings  
+# Settings.llm = HuggingFaceInferenceAPI(  
+#     model_name=repo_id,  
+#     tokenizer_name=repo_id,  
+#     context_window=3000,  
 #     token=HF_TOKEN,  
+#     max_new_tokens=512,  
+#     generate_kwargs={"temperature": 0.1},  
 # )  
-
-# # # Configure Llama index settings  
-# # Settings.llm = HuggingFaceInferenceAPI(  
-# #     model_name=repo_id,  
-# #     tokenizer_name=repo_id,  
-# #     context_window=3000,  
-# #     token=HF_TOKEN,  
-# #     max_new_tokens=512,  
-# #     generate_kwargs={"temperature": 0.1},  
-# # )  
-# # Configure Llama index settings with the new model
-# # Settings.llm = HuggingFaceInferenceAPI(
-# #     model_name=repo_id,
-# #     tokenizer_name=repo_id,  # Use the same tokenizer as the model
-# #     context_window=3000,
-# #     token=HF_TOKEN,
-# #     max_new_tokens=512,
-# #     generate_kwargs={"temperature": 0.1},
-# # )
-# # Settings.embed_model = HuggingFaceEmbedding(  
-# #     model_name="BAAI/bge-small-en-v1.5"  
-# # )  
-# # Replace the embedding model with XLM-R
-# # Settings.embed_model = HuggingFaceEmbedding(
-# #     model_name="xlm-roberta-base"  # XLM-RoBERTa model for multilingual support
-# # )
-# # Settings.embed_model = HuggingFaceEmbedding(
-# #     model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-# # )
-
-# # # Configure tokenizer and model if required
-# # tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base")
-# # model = AutoModel.from_pretrained("xlm-roberta-base")
-# # Configure tokenizer and model if required
-# tokenizer = AutoTokenizer.from_pretrained(repo_id)  # Use the tokenizer from the new model
-# # model = AutoModel.from_pretrained(repo_id)  # Load the new model
-# model = AutoModelForCausalLM.from_pretrained(
-#     repo_id,
-#     load_in_4bit=True,  # Load in 4-bit quantization
-#     torch_dtype=torch.float16,
-#     device_map="auto",
-# )
-# # Configure Llama index settings
+# Configure Llama index settings with the new model
 # Settings.llm = HuggingFaceInferenceAPI(
 #     model_name=repo_id,
 #     tokenizer_name=repo_id,  # Use the same tokenizer as the model
-#     context_window=2048,  # Reduce context window to save memory
+#     context_window=3000,
 #     token=HF_TOKEN,
-#     max_new_tokens=256,  # Reduce max tokens to save memory
+#     max_new_tokens=512,
 #     generate_kwargs={"temperature": 0.1},
 # )
-# # Use a smaller embedding model
+# Settings.embed_model = HuggingFaceEmbedding(  
+#     model_name="BAAI/bge-small-en-v1.5"  
+# )  
+# Replace the embedding model with XLM-R
 # Settings.embed_model = HuggingFaceEmbedding(
-#     model_name="sentence-transformers/all-MiniLM-L6-v2"  # Smaller and faster
+#     model_name="xlm-roberta-base"  # XLM-RoBERTa model for multilingual support
 # )
-# PERSIST_DIR = "db"  
-# PDF_DIRECTORY = 'data'  
-
-# # Ensure directories exist  
-# os.makedirs(PDF_DIRECTORY, exist_ok=True)  
-# os.makedirs(PERSIST_DIR, exist_ok=True)  
-# chat_history = []  
-# current_chat_history = []  
-
-# def data_ingestion_from_directory():  
-#     # Clear previous data by removing the persist directory  
-#     if os.path.exists(PERSIST_DIR):  
-#         shutil.rmtree(PERSIST_DIR)  # Remove the persist directory and all its contents  
-    
-#     # Recreate the persist directory after removal  
-#     os.makedirs(PERSIST_DIR, exist_ok=True)  
-    
-#     # Load new documents from the directory  
-#     new_documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()  
+# Settings.embed_model = HuggingFaceEmbedding(
+#     model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+# )
+
+# # Configure tokenizer and model if required
+# tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base")
+# model = AutoModel.from_pretrained("xlm-roberta-base")
+# Configure tokenizer and model if required
+tokenizer = AutoTokenizer.from_pretrained(repo_id)  # Use the tokenizer from the new model
+# model = AutoModel.from_pretrained(repo_id)  # Load the new model
+model = AutoModelForCausalLM.from_pretrained(
+    repo_id,
+    load_in_4bit=True,  # Load in 4-bit quantization
+    torch_dtype=torch.float16,
+    device_map="auto",
+)
+# Configure Llama index settings
+Settings.llm = HuggingFaceInferenceAPI(
+    model_name=repo_id,
+    tokenizer_name=repo_id,  # Use the same tokenizer as the model
+    context_window=2048,  # Reduce context window to save memory
+    token=HF_TOKEN,
+    max_new_tokens=256,  # Reduce max tokens to save memory
+    generate_kwargs={"temperature": 0.1},
+)
+# Use a smaller embedding model
+Settings.embed_model = HuggingFaceEmbedding(
+    model_name="sentence-transformers/all-MiniLM-L6-v2"  # Smaller and faster
+)
+PERSIST_DIR = "db"  
+PDF_DIRECTORY = 'data'  
+
+# Ensure directories exist  
+os.makedirs(PDF_DIRECTORY, exist_ok=True)  
+os.makedirs(PERSIST_DIR, exist_ok=True)  
+chat_history = []  
+current_chat_history = []  
+
+def data_ingestion_from_directory():  
+    # Clear previous data by removing the persist directory  
+    if os.path.exists(PERSIST_DIR):  
+        shutil.rmtree(PERSIST_DIR)  # Remove the persist directory and all its contents  
     
-#     # Create a new index with the new documents  
-#     index = VectorStoreIndex.from_documents(new_documents)  
+    # Recreate the persist directory after removal  
+    os.makedirs(PERSIST_DIR, exist_ok=True)  
     
-#     # Persist the new index  
-#     index.storage_context.persist(persist_dir=PERSIST_DIR)  
-
-# # def handle_query(query):  
-# #     context_str = ""  
+    # Load new documents from the directory  
+    new_documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()  
     
-# #     # Build context from current chat history  
-# #     for past_query, response in reversed(current_chat_history):  
-# #         if past_query.strip():  
-# #             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"  
+    # Create a new index with the new documents  
+    index = VectorStoreIndex.from_documents(new_documents)  
     
-# #     chat_text_qa_msgs = [
-# #         (
-# #             "user",
-# #             """
-# #             You are the Taj Hotel voice chatbot and your name is Taj hotel helper. Your goal is to provide accurate, professional, and helpful answers to user queries based on the Taj hotel data. Always ensure your responses are clear and concise. Give response within 10-15 words only. You need to give an answer in the same language used by the user.       
-# #             {context_str}
-# #             Question:
-# #             {query_str}
-# #             """
-# #         )
-# #     ]
-
+    # Persist the new index  
+    index.storage_context.persist(persist_dir=PERSIST_DIR)  
 
+# def handle_query(query):  
+#     context_str = ""  
     
-# #     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)  
+#     # Build context from current chat history  
+#     for past_query, response in reversed(current_chat_history):  
+#         if past_query.strip():  
+#             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"  
     
-# #     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)  
-# #     index = load_index_from_storage(storage_context)  
-# #     # context_str = ""  
-    
-# #     # # Build context from current chat history  
-# #     # for past_query, response in reversed(current_chat_history):  
-# #     #     if past_query.strip():  
-# #     #         context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"  
-
-# #     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)  
-# #     print(f"Querying: {query}")  
-# #     answer = query_engine.query(query)  
-
-# #     # Extracting the response  
-# #     if hasattr(answer, 'response'):  
-# #         response = answer.response  
-# #     elif isinstance(answer, dict) and 'response' in answer:  
-# #         response = answer['response']  
-# #     else:  
-# #         response = "I'm sorry, I couldn't find an answer to that."  
-
-# #     # Append to chat history  
-# #     current_chat_history.append((query, response))  
-# #     return response
-# def handle_query(query):
 #     chat_text_qa_msgs = [
 #         (
 #             "user",
 #             """
-#             You are the Hotel voice chatbot and your name is hotel helper. Your goal is to provide accurate, professional, and helpful answers to user queries based on the hotel's data. Always ensure your responses are clear and concise. Give response within 10-15 words only. You need to give an answer in the same language used by the user.       
+#             You are the Taj Hotel voice chatbot and your name is Taj hotel helper. Your goal is to provide accurate, professional, and helpful answers to user queries based on the Taj hotel data. Always ensure your responses are clear and concise. Give response within 10-15 words only. You need to give an answer in the same language used by the user.       
 #             {context_str}
 #             Question:
 #             {query_str}
 #             """
 #         )
 #     ]
-#     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
-    
-#     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
-#     index = load_index_from_storage(storage_context)
-#     context_str = ""
-#     for past_query, response in reversed(current_chat_history):
-#         if past_query.strip():
-#             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"
-
-#     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)
-#     print(query)
-#     answer = query_engine.query(query)
-
-#     if hasattr(answer, 'response'):
-#         response = answer.response
-#     elif isinstance(answer, dict) and 'response' in answer:
-#         response = answer['response']
-#     else:
-#         response = "Sorry, I couldn't find an answer."
-#     current_chat_history.append((query, response))
-#     return response
-
-# app = Flask(__name__)  
-
-# # Data ingestion  
-# data_ingestion_from_directory()  
-
-# # Generate Response
-# def generate_response(query, language):  
-#     try:  
-#         # Call the handle_query function to get the response  
-#         bot_response = handle_query(query)
-        
-#         # Map of supported languages
-#         supported_languages = {
-#             "hindi": "hi",
-#             "bengali": "bn",
-#             "telugu": "te",
-#             "marathi": "mr",
-#             "tamil": "ta",
-#             "gujarati": "gu",
-#             "kannada": "kn",
-#             "malayalam": "ml",
-#             "punjabi": "pa",
-#             "odia": "or",
-#             "urdu": "ur",
-#             "assamese": "as",
-#             "sanskrit": "sa",
-#             "arabic": "ar",
-#             "australian": "en-AU",
-#             "bangla-india": "bn-IN",
-#             "chinese": "zh-CN",
-#             "dutch": "nl",
-#             "french": "fr",
-#             "filipino": "tl",
-#             "greek": "el",
-#             "indonesian": "id",
-#             "italian": "it",
-#             "japanese": "ja",
-#             "korean": "ko",
-#             "latin": "la",
-#             "nepali": "ne",
-#             "portuguese": "pt",
-#             "romanian": "ro",
-#             "russian": "ru",
-#             "spanish": "es",
-#             "swedish": "sv",
-#             "thai": "th",
-#             "ukrainian": "uk",
-#             "turkish": "tr"
-#         }
-        
-#         # Initialize the translated text
-#         translated_text = bot_response
-        
-#         # Translate only if the language is supported and not English
-#         try:
-#             if language in supported_languages:
-#                 target_lang = supported_languages[language]
-#                 translated_text = GoogleTranslator(source='en', target=target_lang).translate(bot_response)
-#                 print(translated_text)
-#             else:
-#                 print(f"Unsupported language: {language}")
-#         except Exception as e:
-#             # Handle translation errors
-#             print(f"Translation error: {e}")
-#             translated_text = "Sorry, I couldn't translate the response."
-        
-#         # Append to chat history
-#         chat_history.append((query, translated_text))
-#         return translated_text  
-#     except Exception as e:  
-#         return f"Error fetching the response: {str(e)}"
-
-# # Route for the homepage  
-# @app.route('/')  
-# def index():  
-#     return render_template('index.html')  
-
-# # Route to handle chatbot messages  
-# @app.route('/chat', methods=['POST'])  
-# def chat():  
-#     try:  
-#         user_message = request.json.get("message")
-#         language = request.json.get("language")
-#         if not user_message:  
-#             return jsonify({"response": "Please say something!"})  
-
-#         bot_response = generate_response(user_message,language)  
-#         return jsonify({"response": bot_response})  
-#     except Exception as e:  
-#         return jsonify({"response": f"An error occurred: {str(e)}"})  
-
-# if __name__ == '__main__':  
-#     app.run(debug=True)
-import os
-import shutil
-from flask import Flask, render_template, request, jsonify
-from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings
-from llama_index.llms.huggingface import HuggingFaceInferenceAPI
-from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-from huggingface_hub import InferenceClient
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from deep_translator import GoogleTranslator
-import torch
-
-# Ensure HF_TOKEN is set
-HF_TOKEN = os.getenv("HF_TOKEN")
-if not HF_TOKEN:
-    raise ValueError("HF_TOKEN environment variable not set.")
-
-# Model configuration
-repo_id = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
-
-# Load tokenizer
-tokenizer = AutoTokenizer.from_pretrained(repo_id)
-
-# Load quantized model
-try:
-    model = AutoModelForCausalLM.from_pretrained(
-        repo_id,
-        device_map="auto",  # Automatically distribute across available devices
-        load_in_8bit=True,  # Quantize to 8-bit precision
-        torch_dtype=torch.float16  # Use 16-bit precision
-    )
-except ImportError:
-    raise ImportError("The 'bitsandbytes' library is required for quantization. Please install it using `pip install bitsandbytes`.")
-
-# Configure Llama index settings
-Settings.llm = HuggingFaceInferenceAPI(
-    model_name=repo_id,
-    tokenizer_name=repo_id,  # Use the same tokenizer as the model
-    context_window=2048,  # Reduce context window to save memory
-    token=HF_TOKEN,
-    max_new_tokens=256,  # Reduce max tokens to save memory
-    generate_kwargs={"temperature": 0.1},
-)
 
-# Use a smaller embedding model
-Settings.embed_model = HuggingFaceEmbedding(
-    model_name="sentence-transformers/all-MiniLM-L6-v2"  # Smaller and faster
-)
 
-# Directories
-PERSIST_DIR = "db"
-PDF_DIRECTORY = 'data'
-
-# Ensure directories exist
-os.makedirs(PDF_DIRECTORY, exist_ok=True)
-os.makedirs(PERSIST_DIR, exist_ok=True)
-
-chat_history = []
-current_chat_history = []
-
-def data_ingestion_from_directory():
-    # Clear previous data by removing the persist directory
-    if os.path.exists(PERSIST_DIR):
-        shutil.rmtree(PERSIST_DIR)  # Remove the persist directory and all its contents
     
-    # Recreate the persist directory after removal
-    os.makedirs(PERSIST_DIR, exist_ok=True)
+#     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)  
     
-    # Load new documents from the directory
-    new_documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()
+#     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)  
+#     index = load_index_from_storage(storage_context)  
+#     # context_str = ""  
     
-    # Create a new index with the new documents
-    index = VectorStoreIndex.from_documents(new_documents)
-    
-    # Persist the new index
-    index.storage_context.persist(persist_dir=PERSIST_DIR)
-
+#     # # Build context from current chat history  
+#     # for past_query, response in reversed(current_chat_history):  
+#     #     if past_query.strip():  
+#     #         context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"  
+
+#     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)  
+#     print(f"Querying: {query}")  
+#     answer = query_engine.query(query)  
+
+#     # Extracting the response  
+#     if hasattr(answer, 'response'):  
+#         response = answer.response  
+#     elif isinstance(answer, dict) and 'response' in answer:  
+#         response = answer['response']  
+#     else:  
+#         response = "I'm sorry, I couldn't find an answer to that."  
+
+#     # Append to chat history  
+#     current_chat_history.append((query, response))  
+#     return response
 def handle_query(query):
     chat_text_qa_msgs = [
         (
@@ -376,9 +173,11 @@ def handle_query(query):
     for past_query, response in reversed(current_chat_history):
         if past_query.strip():
             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"
+
     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)
     print(query)
     answer = query_engine.query(query)
+
     if hasattr(answer, 'response'):
         response = answer.response
     elif isinstance(answer, dict) and 'response' in answer:
@@ -388,10 +187,10 @@ def handle_query(query):
     current_chat_history.append((query, response))
     return response
 
-app = Flask(__name__)
+app = Flask(__name__)  
 
-# Data ingestion
-data_ingestion_from_directory()
+# Data ingestion  
+data_ingestion_from_directory()  
 
 # Generate Response
 def generate_response(query, language):  
@@ -473,10 +272,211 @@ def chat():
         language = request.json.get("language")
         if not user_message:  
             return jsonify({"response": "Please say something!"})  
-        bot_response = generate_response(user_message, language)  
+
+        bot_response = generate_response(user_message,language)  
         return jsonify({"response": bot_response})  
     except Exception as e:  
         return jsonify({"response": f"An error occurred: {str(e)}"})  
 
 if __name__ == '__main__':  
-    app.run(debug=True)
+    app.run(debug=True)
+# import os
+# import shutil
+# from flask import Flask, render_template, request, jsonify
+# from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings
+# from llama_index.llms.huggingface import HuggingFaceInferenceAPI
+# from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+# from huggingface_hub import InferenceClient
+# from transformers import AutoTokenizer, AutoModelForCausalLM
+# from deep_translator import GoogleTranslator
+# import torch
+
+# # Ensure HF_TOKEN is set
+# HF_TOKEN = os.getenv("HF_TOKEN")
+# if not HF_TOKEN:
+#     raise ValueError("HF_TOKEN environment variable not set.")
+
+# # Model configuration
+# repo_id = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+
+# # Load tokenizer
+# tokenizer = AutoTokenizer.from_pretrained(repo_id)
+
+# # Load quantized model
+# try:
+#     model = AutoModelForCausalLM.from_pretrained(
+#         repo_id,
+#         device_map="auto",  # Automatically distribute across available devices
+#         load_in_8bit=True,  # Quantize to 8-bit precision
+#         torch_dtype=torch.float16  # Use 16-bit precision
+#     )
+# except ImportError:
+#     raise ImportError("The 'bitsandbytes' library is required for quantization. Please install it using `pip install bitsandbytes`.")
+
+# # Configure Llama index settings
+# Settings.llm = HuggingFaceInferenceAPI(
+#     model_name=repo_id,
+#     tokenizer_name=repo_id,  # Use the same tokenizer as the model
+#     context_window=2048,  # Reduce context window to save memory
+#     token=HF_TOKEN,
+#     max_new_tokens=256,  # Reduce max tokens to save memory
+#     generate_kwargs={"temperature": 0.1},
+# )
+
+# # Use a smaller embedding model
+# Settings.embed_model = HuggingFaceEmbedding(
+#     model_name="sentence-transformers/all-MiniLM-L6-v2"  # Smaller and faster
+# )
+
+# # Directories
+# PERSIST_DIR = "db"
+# PDF_DIRECTORY = 'data'
+
+# # Ensure directories exist
+# os.makedirs(PDF_DIRECTORY, exist_ok=True)
+# os.makedirs(PERSIST_DIR, exist_ok=True)
+
+# chat_history = []
+# current_chat_history = []
+
+# def data_ingestion_from_directory():
+#     # Clear previous data by removing the persist directory
+#     if os.path.exists(PERSIST_DIR):
+#         shutil.rmtree(PERSIST_DIR)  # Remove the persist directory and all its contents
+    
+#     # Recreate the persist directory after removal
+#     os.makedirs(PERSIST_DIR, exist_ok=True)
+    
+#     # Load new documents from the directory
+#     new_documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()
+    
+#     # Create a new index with the new documents
+#     index = VectorStoreIndex.from_documents(new_documents)
+    
+#     # Persist the new index
+#     index.storage_context.persist(persist_dir=PERSIST_DIR)
+
+# def handle_query(query):
+#     chat_text_qa_msgs = [
+#         (
+#             "user",
+#             """
+#             You are the Hotel voice chatbot and your name is hotel helper. Your goal is to provide accurate, professional, and helpful answers to user queries based on the hotel's data. Always ensure your responses are clear and concise. Give response within 10-15 words only. You need to give an answer in the same language used by the user.       
+#             {context_str}
+#             Question:
+#             {query_str}
+#             """
+#         )
+#     ]
+#     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
+    
+#     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
+#     index = load_index_from_storage(storage_context)
+#     context_str = ""
+#     for past_query, response in reversed(current_chat_history):
+#         if past_query.strip():
+#             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"
+#     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)
+#     print(query)
+#     answer = query_engine.query(query)
+#     if hasattr(answer, 'response'):
+#         response = answer.response
+#     elif isinstance(answer, dict) and 'response' in answer:
+#         response = answer['response']
+#     else:
+#         response = "Sorry, I couldn't find an answer."
+#     current_chat_history.append((query, response))
+#     return response
+
+# app = Flask(__name__)
+
+# # Data ingestion
+# data_ingestion_from_directory()
+
+# # Generate Response
+# def generate_response(query, language):  
+#     try:  
+#         # Call the handle_query function to get the response  
+#         bot_response = handle_query(query)
+        
+#         # Map of supported languages
+#         supported_languages = {
+#             "hindi": "hi",
+#             "bengali": "bn",
+#             "telugu": "te",
+#             "marathi": "mr",
+#             "tamil": "ta",
+#             "gujarati": "gu",
+#             "kannada": "kn",
+#             "malayalam": "ml",
+#             "punjabi": "pa",
+#             "odia": "or",
+#             "urdu": "ur",
+#             "assamese": "as",
+#             "sanskrit": "sa",
+#             "arabic": "ar",
+#             "australian": "en-AU",
+#             "bangla-india": "bn-IN",
+#             "chinese": "zh-CN",
+#             "dutch": "nl",
+#             "french": "fr",
+#             "filipino": "tl",
+#             "greek": "el",
+#             "indonesian": "id",
+#             "italian": "it",
+#             "japanese": "ja",
+#             "korean": "ko",
+#             "latin": "la",
+#             "nepali": "ne",
+#             "portuguese": "pt",
+#             "romanian": "ro",
+#             "russian": "ru",
+#             "spanish": "es",
+#             "swedish": "sv",
+#             "thai": "th",
+#             "ukrainian": "uk",
+#             "turkish": "tr"
+#         }
+        
+#         # Initialize the translated text
+#         translated_text = bot_response
+        
+#         # Translate only if the language is supported and not English
+#         try:
+#             if language in supported_languages:
+#                 target_lang = supported_languages[language]
+#                 translated_text = GoogleTranslator(source='en', target=target_lang).translate(bot_response)
+#                 print(translated_text)
+#             else:
+#                 print(f"Unsupported language: {language}")
+#         except Exception as e:
+#             # Handle translation errors
+#             print(f"Translation error: {e}")
+#             translated_text = "Sorry, I couldn't translate the response."
+        
+#         # Append to chat history
+#         chat_history.append((query, translated_text))
+#         return translated_text  
+#     except Exception as e:  
+#         return f"Error fetching the response: {str(e)}"
+
+# # Route for the homepage  
+# @app.route('/')  
+# def index():  
+#     return render_template('index.html')  
+
+# # Route to handle chatbot messages  
+# @app.route('/chat', methods=['POST'])  
+# def chat():  
+#     try:  
+#         user_message = request.json.get("message")
+#         language = request.json.get("language")
+#         if not user_message:  
+#             return jsonify({"response": "Please say something!"})  
+#         bot_response = generate_response(user_message, language)  
+#         return jsonify({"response": bot_response})  
+#     except Exception as e:  
+#         return jsonify({"response": f"An error occurred: {str(e)}"})  
+
+# if __name__ == '__main__':  
+#     app.run(debug=True)