Upload folder using huggingface_hub

README.md

@@ -1,12 +1,6 @@
 ---
-title: Agent App
-emoji: 📊
-colorFrom: pink
-colorTo: yellow
+title: agent_app
+app_file: main.py
 sdk: gradio
 sdk_version: 4.37.2
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

leave.py

@@ -0,0 +1,101 @@
+from langchain.tools import BaseTool
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_community.utilities import SQLDatabase
+from langchain.schema import SystemMessage, HumanMessage, AIMessage
+import os
+import psycopg2
+import gradio as gr
+
+# Set up database connection details
+pg_uri = "postgresql://ridhima:0skESLQ9D6c3m7smqwG47peapk7HzVvu@dpg-cq2h613v2p9s73esp8eg-a.singapore-postgres.render.com/hr_qugd"
+
+def get_db_connection():
+    conn = psycopg2.connect(pg_uri)
+    return conn
+
+class LeaveRequestInfoTool(BaseTool):
+    name = "leave_request_information"
+    description = "Provides information about the leave request process and database schema."
+
+    def _run(self, query: str) -> str:
+        return """
+        Leave Request Process:
+        1. Collect employee ID
+        2. Ask for leave type
+        3. Get reason for leave
+        4. Get start date of leave
+        5. Get end date of leave
+        6. Calculate duration (in days)
+        7. Insert data into request table
+        8. Confirm submission to user
+
+        Database Schema:
+        Table: request
+        Columns:
+        - leave_id (auto-increment integer)
+        - employee_id (integer)
+        - leave_type (text)
+        - reason (text)
+        - start_of_leave (date)
+        - end_of_leave (date)
+        - duration (integer, calculated in days)
+        - leave_status (text, default 'Pending')
+
+        Instructions:
+        - Collect all necessary information from the user one by one.
+        - Calculate the duration as the number of days between start_of_leave and end_of_leave.
+        - Once all information is collected, formulate an SQL INSERT statement for the 'request' table.
+        - REMEMBER TO EXECUTE THE INSERT QUERY FOR EACH REQUEST ONLY ONCE.
+        - CRITICAL: EXECUTE THE INSERT QUERY FOR EACH REQUEST ONLY ONCE.
+        - If you receive an error message saying an insertion has already been made, DO NOT attempt to insert again.
+        - Instead, inform the user that their request has been submitted and ask if they need anything else.
+        - After insertion, confirm to the user that their request has been submitted.
+        """
+
+class SQLAgentTool(BaseTool):
+    name = "sql_agent"
+    description = "Use this tool to interact with the database and execute SQL queries."
+    
+    def _run(self, query: str) -> str:
+        print("Executing Query:  ", query)
+        conn = get_db_connection()
+        cur = conn.cursor()
+        try:
+            cur.execute(query)
+            conn.commit()
+            result = "Your leave request has been submitted successfully."
+        except Exception as e:
+            conn.rollback()
+            result = f"An error occurred: {str(e)}"
+        finally:
+            cur.close()
+            conn.close()
+        return result
+
+prompt = ChatPromptTemplate.from_messages([
+    SystemMessage(content="""You are an HR assistant. You can help with leave requests and provide information about company policies.
+    - For leave requests, ask for each piece of information one at a time. After collecting all information, use the sql_agent tool to INSERT the data into the 'request' table.
+    - For information queries about company policies, use the rag_info tool to provide accurate information from the RAG-trained model.
+    
+    The pieces of information you need to collect for leave requests are:
+    1. Employee ID
+    2. Leave Type
+    3. Reason for Leave
+    4. Start Date of Leave (YYYY-MM-DD)
+    5. End Date of Leave (YYYY-MM-DD)
+    Calculate the duration as the number of days between start and end dates using PostgreSQL functions and convert duration to integer.
+    Use 'Pending' as the default leave_status.
+
+    Remember to use the correct column names as per the table structure:
+    request(leave_id, employee_id, leave_type, reason, start_of_leave, end_of_leave, duration, leave_status)
+    Where leave_id is auto-increment and should not be included in the INSERT statement.
+    
+    For company policies, provide detailed and accurate information based on the RAG-trained model.
+    """),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("human", "{input}"),
+    MessagesPlaceholder(variable_name="agent_scratchpad")
+])
+

main.py

@@ -0,0 +1,61 @@
+import gradio as gr
+import os
+from langchain.schema import HumanMessage, AIMessage
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from rag import create_rag_tool
+from leave import LeaveRequestInfoTool, SQLAgentTool, prompt
+
+
+# Initialize LLM
+key = "sk-proj-LdVhjM2bTI27bA3grOK8T3BlbkFJh5whi2UHYKkgM2pNwpbe"
+os.environ["OPENAI_API_KEY"] = key
+
+llm = ChatOpenAI(model="gpt-4", temperature=0)
+
+# Add the RAGTool to the list of tools
+rag_tool = create_rag_tool(llm=llm)
+leave_request_info_tool = LeaveRequestInfoTool()
+sql_tool = SQLAgentTool()
+
+tools = [leave_request_info_tool, sql_tool, rag_tool]
+
+agent = create_openai_tools_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+def truncate_chat_history(chat_history, max_tokens=3000):
+    total_tokens = sum(len(message.content.split()) for message in chat_history)
+    while total_tokens > max_tokens and chat_history:
+        chat_history.pop(0)
+        total_tokens = sum(len(message.content.split()) for message in chat_history)
+    return chat_history
+
+def handle_user_input(user_input, chat_history):
+    if chat_history is None:
+        chat_history = []
+    
+    chat_history.append(HumanMessage(content=user_input))
+    truncated_chat_history = truncate_chat_history(chat_history)
+    
+    response = agent_executor.invoke(
+        {"input": user_input, "chat_history": truncated_chat_history}
+    )
+    ai_response = response['output']
+    
+    chat_history.append(AIMessage(content=ai_response))
+    
+    messages = [(message.content, "user" if isinstance(message, HumanMessage) else "bot") for message in chat_history]
+    return messages, chat_history
+
+with gr.Blocks() as demo:
+    gr.Markdown("# HR Assistant Chatbot")
+    chatbot = gr.Chatbot()
+    state = gr.State()
+    txt = gr.Textbox(placeholder="Type your message here...")
+
+    txt.submit(handle_user_input, [txt, state], [chatbot, state])
+
+demo.launch(share = True)
+
+
+

rag.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, Field
+from langchain.tools import Tool
+from langchain_community.vectorstores import Neo4jVector
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain import hub
+import os
+
+# Initialize LLM
+key = "sk-proj-LdVhjM2bTI27bA3grOK8T3BlbkFJh5whi2UHYKkgM2pNwpbe"
+os.environ["OPENAI_API_KEY"] = key
+
+class RAGToolConfig(BaseModel):
+    NEO4J_URI: str = Field(default="neo4j+s://741a3118.databases.neo4j.io")
+    NEO4J_USERNAME: str = Field(default="neo4j")
+    NEO4J_PASSWORD: str = Field(default="XvUolnAXmgx9SG_lRSJuisbDClxi2MiTKGIoBdqN53A")
+    pdf_path: str = Field(default="/mnt/d/atx/hragent/rag/Sirca_Paints.pdf")
+
+class RAGToolImplementation:
+    def __init__(self, config: RAGToolConfig, llm):
+        self.config = config
+        self.llm = llm  # Store the llm instance
+        self.embedding_model = OpenAIEmbeddings()
+        self.vectorstore = self._initialize_vectorstore()
+        self.rag_chain = self._setup_rag_chain()
+
+    def _initialize_vectorstore(self):
+        try:
+            # Try to load existing vector store
+            vectorstore = Neo4jVector(
+                url=self.config.NEO4J_URI,
+                username=self.config.NEO4J_USERNAME,
+                password=self.config.NEO4J_PASSWORD,
+                embedding=self.embedding_model,
+                index_name="pdf_embeddings",
+                node_label="PDFChunk",
+                text_node_property="text",
+                embedding_node_property="embedding"
+            )
+            vectorstore.similarity_search("Test query", k=1)
+            print("Existing vector store loaded.")
+        except Exception as e:
+            print(f"Creating new vector store. Error: {e}")
+            # Load and process the PDF
+            loader = PyPDFLoader(self.config.pdf_path)
+            docs = loader.load()
+
+            # Split the document into chunks
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+            splits = text_splitter.split_documents(docs)
+
+            # Create new vector store
+            vectorstore = Neo4jVector.from_documents(
+                documents=splits,
+                embedding=self.embedding_model,
+                url=self.config.NEO4J_URI,
+                username=self.config.NEO4J_USERNAME,
+                password=self.config.NEO4J_PASSWORD,
+                index_name="pdf_embeddings",
+                node_label="PDFChunk",
+                text_node_property="text",
+                embedding_node_property="embedding"
+            )
+            print("New vector store created and loaded.")
+        return vectorstore
+    
+    def _setup_rag_chain(self):
+        retriever = self.vectorstore.as_retriever()
+        prompt = hub.pull("rlm/rag-prompt")
+
+        def format_docs(docs):
+            return "\n\n".join(doc.page_content for doc in docs)
+
+        rag_chain = (
+            {"context": retriever | format_docs, "question": RunnablePassthrough()}
+            | prompt
+            | self.llm  # Use the llm instance here
+            | StrOutputParser()
+        )
+        return rag_chain
+
+    def run(self, query: str) -> str:
+        try:
+            response = self.rag_chain.invoke(query)
+            return response
+        except Exception as e:
+            return f"An error occurred while processing the query: {str(e)}"
+        
+
+def create_rag_tool(config: RAGToolConfig = RAGToolConfig(), llm=None):
+    implementation = RAGToolImplementation(config, llm)
+    return Tool(
+        name="RAGTool",
+        description="Retrieval-Augmented Generation Tool for querying PDF content about Sirca Paints",
+        func=implementation.run
+    )
+
+# # Example Usage
+# if __name__ == "__main__":
+#     llm = ChatOpenAI(model="gpt-4", temperature=0)
+#     rag_tool = create_rag_tool(llm=llm)
+
+#     # Test the tool
+#     result = rag_tool.run("What is spil ethics?")
+#     print(result)