Create app.py

app.py

@@ -0,0 +1,99 @@
+import os
+import gradio as gr
+from langchain.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from langchain.chat_models import ChatOpenAI
+
+class AuditCopilot:
+    def __init__(self):
+        # Hardcoded OpenAI API key
+        self.openai_api_key = "your-api-key-here"  # Replace with your actual API key
+        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 = "guidelines.pdf"  # Replace with your PDF filename
+            
+            # Load and split document
+            loader = PyPDFLoader(pdf_path)
+            documents = loader.load()
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=1000,
+                chunk_overlap=200
+            )
+            splits = text_splitter.split_documents(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
+            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
+            )
+            
+            print("System initialized successfully!")
+            
+        except Exception as e:
+            print(f"Error initializing system: {str(e)}")
+    
+    def get_response(self, question):
+        """Get response from the chain"""
+        try:
+            response = self.chain({"question": question})
+            self.chat_history.append((question, response['answer']))
+            return response['answer']
+        except Exception as e:
+            return f"Error generating response: {str(e)}"
+
+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!")
+        
+        # Chat section
+        chatbot = gr.Chatbot(label="Conversation")
+        msg = gr.Textbox(label="Ask a question")
+        clear = gr.Button("Clear")
+        
+        def respond(message, chat_history):
+            bot_message = copilot.get_response(message)
+            chat_history.append((message, bot_message))
+            return "", chat_history
+        
+        # Connect components
+        msg.submit(respond, [msg, chatbot], [msg, chatbot])
+        clear.click(lambda: None, None, chatbot, queue=False)
+    
+    return demo
+
+if __name__ == "__main__":
+    try:
+        demo = create_gradio_interface()
+        demo.launch()
+    except Exception as e:
+        print(f"Error launching application: {str(e)}")