Create app.py

app.py

@@ -0,0 +1,167 @@
+import gradio as gr
+import time
+import os
+from langchain.document_loaders import TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores import SKLearnVectorStore
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain.llms import ChatOllama
+from langchain.schema.output_parser import StrOutputParser
+
+# Define the RAG application class
+class RAGApplication:
+    def __init__(self, retriever, rag_chain, memory):
+        self.retriever = retriever
+        self.rag_chain = rag_chain
+        self.memory = memory
+        # Initialize metadata placeholders
+        self.metadata = {
+            'File Name': None,
+            'File Size': None,
+            'Document Processing Time': None,
+            'Response Time': None
+        }
+
+    def run(self, question):
+        start_time = time.time()
+        # Retrieve relevant documents
+        documents = self.retriever.invoke(question)
+        doc_texts = "\n".join([doc.page_content for doc in documents])
+
+        # Update the memory with the user's question
+        self.memory.append({"role": "user", "content": question})
+
+        # Build a conversation context from memory
+        conversation_history = "\n".join([
+            f"[{entry['role'].upper()}]: {entry['content']}" for entry in self.memory
+        ])
+
+        # Prepare input for the chain
+        chain_input = {
+            "question": question,
+            "documents": doc_texts,
+            "history": conversation_history
+        }
+
+        # Get the answer from the language model
+        answer = self.rag_chain.invoke(chain_input)
+
+        end_time = time.time()
+        # Record the response time
+        self.metadata['Response Time'] = f"{round(end_time - start_time, 2)} seconds"
+
+        # Update memory with the assistant's response
+        self.memory.append({"role": "assistant", "content": answer})
+        return answer
+
+
+@st.cache_data
+def load_data(json_file_path: str):
+    with open(json_file_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def make_string(obj: dict):
+    string = ""
+    keys = list(obj.keys())
+
+    for k in keys:
+        if isinstance(obj[k], str):
+            string += f"\"{k.capitalize().replace('_', ' ')}\": {obj[k]}\n"
+        elif isinstance(obj[k], list):
+            string += f"\"{k.capitalize().replace('_', ' ')}\": {', '.join(obj[k])}\n"
+    return string
+    
+
+def main():
+    # Load the Markdown file
+    markdown_file_path = "file.md"
+    loader = TextLoader(markdown_file_path, encoding='utf-8')
+
+    # Time the document processing
+    start_time = time.time()
+    documents = loader.load()
+    end_time = time.time()
+    file_processing_time = round(end_time - start_time, 2)
+
+    # Get file size
+    file_size = os.path.getsize(markdown_file_path) if os.path.exists(markdown_file_path) else 0
+
+    # Split the text into chunks
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,  # Adjust to needs
+        chunk_overlap=100  # Overlap to maintain context
+    )
+    split_docs = text_splitter.split_documents(documents)
+
+    # Create embeddings and vector store
+    vectorstore = SKLearnVectorStore.from_documents(
+        documents=split_docs,
+        embedding=OpenAIEmbeddings(openai_api_key="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"),
+    )
+    retriever = vectorstore.as_retriever(k=4)
+
+    # Define the prompt template
+    prompt = PromptTemplate(
+        template="""
+        You are an AI assistant specialized in providing information about HR policies and guidelines.
+        You have access to HR documents containing policies, guidelines, processes, and other related data.
+        Here is the conversation history so far:
+        {history}
+        Use the provided documents to answer the user’s question about HR matters in a concise and precise manner.
+        If you don't know the answer, just say that you don't know.
+        Use three sentences maximum.
+        
+        Question: {question}
+        Documents: {documents}
+        Answer:""",
+        input_variables=["history", "question", "documents"],
+    )
+
+    # Initialize the LLM
+    llm = ChatOllama(
+        model="llama3.3:7b",
+        temperature=0.5,
+    )
+
+    # Create a chain combining the prompt and LLM
+    rag_chain = prompt | llm | StrOutputParser()
+
+    # Conversation history
+    conversation_history = []
+
+    # Function to handle user queries
+    def chat_interface(user_input, history):
+        nonlocal conversation_history
+        
+        # Store conversation history
+        formatted_history = "\n".join([f"User: {h[0]}\nAssistant: {h[1]}" for h in history])
+        
+        # Run RAG application
+        output = rag_chain.invoke({"history": formatted_history, "question": user_input, "documents": documents})
+        conversation_history.append({"role": "user", "content": user_input})
+        conversation_history.append({"role": "assistant", "content": output})
+        return output
+
+    # Create Gradio Interface
+    with gr.Blocks() as iface:
+        gr.Markdown("# HR Talk - AI Assistant")
+        with gr.Row():
+            with gr.Column():
+                chat = gr.Chatbot()
+                query = gr.Textbox(label="Ask a question about HR policies...")
+                submit = gr.Button("Submit")
+                
+        with gr.Accordion("Metadata", open=False):
+            gr.Markdown(f"**File Name:** {markdown_file_path}\n")
+            gr.Markdown(f"**File Size:** {file_size} bytes\n")
+            gr.Markdown(f"**Processing Time:** {file_processing_time} seconds\n")
+        
+        submit.click(chat_interface, inputs=[query, chat], outputs=chat)
+
+    # Launch app
+    iface.launch()
+
+if __name__ == "__main__":
+    main()