Update app.py

app.py

@@ -1,10 +1,14 @@
 import os  
-import pdfplumber  
+import time  
+import datetime  
 import gradio as gr  
-from llama_index.core import StorageContext, SimpleDirectoryReader, ChatPromptTemplate, Settings  
+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 llama_index import VectorStoreIndex  
+from deep_translator import GoogleTranslator  
+
+# Initialize Hugging Face token  
+os.environ["HF_TOKEN"] = os.getenv("HF_TOKEN")  
 
 # Configure Llama index settings  
 Settings.llm = HuggingFaceInferenceAPI(  
@@ -15,35 +19,33 @@ Settings.llm = HuggingFaceInferenceAPI(
     max_new_tokens=512,  
     generate_kwargs={"temperature": 0.1},  
 )  
-
 Settings.embed_model = HuggingFaceEmbedding(  
     model_name="BAAI/bge-small-en-v1.5"  
 )  
 
-# Define directories for persistent storage and PDF data  
 PERSIST_DIR = "db"  
-PDF_DIRECTORY = 'data'  # Directory containing PDFs  
+PDF_DIRECTORY = 'data'  
 
 # Ensure directories exist  
 os.makedirs(PDF_DIRECTORY, exist_ok=True)  
 os.makedirs(PERSIST_DIR, exist_ok=True)  
 
-# Variable to store current chat conversation  
-current_chat_history = []  
-
+# Load and initialize data  
 def data_ingestion_from_directory():  
-    # Use SimpleDirectoryReader on the directory containing the PDF files  
     documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()  
     storage_context = StorageContext.from_defaults()  
     index = VectorStoreIndex.from_documents(documents)  
     index.storage_context.persist(persist_dir=PERSIST_DIR)  
 
-# Load the PDF documents into the index  
-data_ingestion_from_directory()  
+def initialize():  
+    start_time = time.time()  
+    data_ingestion_from_directory()  # Process PDF ingestion at startup  
+    print(f"Data ingestion time: {time.time() - start_time} seconds")  
 
-# Function to handle user queries  
-def handle_query(query):  
-    global current_chat_history  
+initialize()  # Run initialization tasks  
+
+# Handle user queries  
+def handle_query(query, language):  
     chat_text_qa_msgs = [  
         (  
             "user",  
@@ -55,36 +57,49 @@ def handle_query(query):
             """  
         )  
     ]  
-
     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)  
     
     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)  
-    index = VectorStoreIndex.load_from_storage(storage_context)  
-
-    context_str = "\n".join([f"User asked: '{past_query}'\nBot answered: '{response}'"  
-                             for past_query, response in reversed(current_chat_history) if past_query.strip()])  
-
+    index = load_index_from_storage(storage_context)  
+    
+    context_str = ""  
     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)  
-    print(f"Query: {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."  
+
+    # Translate response if needed  
+    if language:  
+        try:  
+            translator = GoogleTranslator(target=language.split('-')[0])  # Translate to the specified language  
+            response = translator.translate(response)  
+        except Exception as e:  
+            print(f"Translation error: {e}")  
+            response = "Sorry, I couldn't translate the response."  
 
-    response = getattr(answer, 'response', answer.get('response', "Sorry, I couldn't find an answer."))  
-    current_chat_history.append((query, response))  
     return response  
 
-# Create Gradio interface  
-def gradio_chatbot(user_input):  
-    response = handle_query(user_input)  
+# Gradio interface  
+def chatbot_interface(message, language):  
+    response = handle_query(message, language)  
     return response  
 
-# Set up Gradio app interface  
+# Create Gradio app  
 iface = gr.Interface(  
-    fn=gradio_chatbot,  
-    inputs=gr.inputs.Textbox(label="Ask a question about the hotel"),  
+    fn=chatbot_interface,  
+    inputs=[  
+        gr.inputs.Textbox(label="Your Message"),  
+        gr.inputs.Textbox(label="Language (e.g., en, fr, es)", default="en")  
+    ],  
     outputs="text",  
     title="Hotel Chatbot",  
-    description="Ask any questions related to the hotel."  
+    description="Ask questions about the hotel and get responses."  
 )  
 
 # Launch the Gradio app