Update app.py

app.py

@@ -1,97 +1,132 @@
 import os
 import gradio as gr
-from langchain.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import PyPDFLoader
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings import OpenAIEmbeddings
-from langchain.vectorstores import FAISS
+from langchain_community.embeddings import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
 from langchain.chains import ConversationalRetrievalChain
 from langchain.memory import ConversationBufferMemory
-from langchain.chat_models import ChatOpenAI
+from langchain_openai import ChatOpenAI
 
 class AuditCopilot:
     def __init__(self):
-        # Hardcoded OpenAI API key
         self.openai_api_key = os.getenv('OPENAI_API_KEY')
         if not self.openai_api_key:
-            raise ValueError("OPENAI_API_KEY environment variable is not set")# Replace with your actual API key
+            raise ValueError("OPENAI_API_KEY environment variable is not set")
+        
         self.vector_store = None
         self.chain = None
         self.chat_history = []
-        # Initialize the system with the PDF
         self.initialize_system()
         
     def initialize_system(self):
         """Initialize the system with the pre-loaded PDF"""
         try:
-            # Path to your PDF file in the same directory as the script
-            pdf_path = "IAASB-Drafting-Principles-Guidelines"  # Replace with your PDF filename
+            # Make sure to include the .pdf extension in the filename
+            pdf_path = "IAASB-Drafting-Principles-Guidelines.pdf"
+            
+            if not os.path.exists(pdf_path):
+                raise FileNotFoundError(f"PDF file not found at path: {pdf_path}")
             
             # Load and split document
             loader = PyPDFLoader(pdf_path)
             documents = loader.load()
+            
+            if not documents:
+                raise ValueError("No content loaded from PDF")
+                
             text_splitter = RecursiveCharacterTextSplitter(
                 chunk_size=1000,
                 chunk_overlap=200
             )
             splits = text_splitter.split_documents(documents)
             
+            if not splits:
+                raise ValueError("No text splits created from documents")
+            
             # Create vector store
             embeddings = OpenAIEmbeddings(openai_api_key=self.openai_api_key)
             self.vector_store = FAISS.from_documents(splits, embeddings)
             
-            # Initialize conversation chain with GPT-3.5-turbo
+            # Initialize conversation chain
             llm = ChatOpenAI(
                 model_name="gpt-3.5-turbo",
                 temperature=0,
                 openai_api_key=self.openai_api_key
             )
+            
             memory = ConversationBufferMemory(
                 memory_key="chat_history",
                 return_messages=True
             )
+            
             self.chain = ConversationalRetrievalChain.from_llm(
                 llm=llm,
                 retriever=self.vector_store.as_retriever(),
-                memory=memory
+                memory=memory,
+                verbose=True  # Added for debugging
             )
             
             print("System initialized successfully!")
             
+        except FileNotFoundError as e:
+            print(f"PDF File Error: {str(e)}")
+            raise
         except Exception as e:
-            print(f"Error initializing system: {str(e)}")
+            print(f"Initialization Error: {str(e)}")
+            raise
     
     def get_response(self, question):
         """Get response from the chain"""
+        if not self.chain:
+            return "Error: System not properly initialized. Please check the PDF file and try again."
+            
         try:
+            if not question or not isinstance(question, str):
+                return "Please provide a valid question."
+                
             response = self.chain({"question": question})
+            
+            if not response or 'answer' not in response:
+                return "Error: Unable to generate a response. Please try again."
+                
             self.chat_history.append((question, response['answer']))
             return response['answer']
+            
         except Exception as e:
-            return f"Error generating response: {str(e)}"
+            error_msg = f"Error generating response: {str(e)}"
+            print(error_msg)  # For logging
+            return error_msg
 
 def create_gradio_interface():
     """Create Gradio interface"""
-    copilot = AuditCopilot()
-    
-    with gr.Blocks() as demo:
-        gr.Markdown("# Audit Copilot")
-        gr.Markdown("Ask questions about the audit guidelines!")
+    try:
+        copilot = AuditCopilot()
         
-        # Chat section
-        chatbot = gr.Chatbot(label="Conversation")
-        msg = gr.Textbox(label="Ask a question")
-        clear = gr.Button("Clear")
+        with gr.Blocks() as demo:
+            gr.Markdown("# Audit Copilot")
+            gr.Markdown("Ask questions about the IAASB Drafting Principles Guidelines!")
+            
+            # Chat section
+            chatbot = gr.Chatbot(label="Conversation")
+            msg = gr.Textbox(label="Ask a question", placeholder="Type your question here...")
+            clear = gr.Button("Clear Chat")
+            
+            def respond(message, chat_history):
+                if not message.strip():
+                    return "", chat_history
+                bot_message = copilot.get_response(message)
+                chat_history.append((message, bot_message))
+                return "", chat_history
+            
+            msg.submit(respond, [msg, chatbot], [msg, chatbot])
+            clear.click(lambda: None, None, chatbot, queue=False)
         
-        def respond(message, chat_history):
-            bot_message = copilot.get_response(message)
-            chat_history.append((message, bot_message))
-            return "", chat_history
+        return demo
         
-        # Connect components
-        msg.submit(respond, [msg, chatbot], [msg, chatbot])
-        clear.click(lambda: None, None, chatbot, queue=False)
-    
-    return demo
+    except Exception as e:
+        print(f"Error creating interface: {str(e)}")
+        raise
 
 if __name__ == "__main__":
     try: