Update app.py

app.py

@@ -12,47 +12,81 @@ from langchain.tools import Tool
 from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain_core.messages import HumanMessage, AIMessage
 
+
 # --- Database Setup ---
+
+# Database initialization with caching
 @st.cache_resource
 def init_db():
     conn = sqlite3.connect('users.db', check_same_thread=False)
     c = conn.cursor()
-    
-    # Users table
     c.execute('''CREATE TABLE IF NOT EXISTS users
                  (id INTEGER PRIMARY KEY AUTOINCREMENT,
                   username TEXT UNIQUE NOT NULL,
                   password TEXT NOT NULL,
                   previous_chat_history TEXT,
                   previous_products_bought TEXT)''')
-    
-    # Company settings table
-    c.execute('''CREATE TABLE IF NOT EXISTS company_settings
-                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
-                  company_name TEXT,
-                  company_business TEXT,
-                  agent_name TEXT,
-                  key_features TEXT)''')
-    
-    # Insert default settings if empty
-    c.execute('SELECT COUNT(*) FROM company_settings')
-    if c.fetchone()[0] == 0:
-        c.execute('''INSERT INTO company_settings 
-                     (company_name, company_business, agent_name, key_features)
-                     VALUES (?, ?, ?, ?)''',
-                  ("TechElectronics", 
-                   "Consumer Electronics Retailer",
-                   "Alex",
-                   "Cutting-edge technology, Competitive pricing, Excellent customer service"))
     conn.commit()
     return conn
 
 conn = init_db()
 
+
 class User:
-    # ... (existing User class remains unchanged) ...
+    def __init__(self, id, username, password, chat_history = None, products_bought = None):
+        self.id = id
+        self.username = username
+        self.password = password
+        self.chat_history = chat_history or []
+        self.products_bought = products_bought or []
+
+    # To register a new user
+    @classmethod
+    def create(cls, username, password):
+        hashed_pw = generate_password_hash(password)
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        c.execute('INSERT INTO users (username, password) VALUES (?, ?)',(username, hashed_pw))
+        user_id = c.lastrowid
+        conn.commit()
+        conn.close()
+        return cls(user_id, username, hashed_pw)    
+
+     # To retrieve an existing user from the database by username.
+    @classmethod
+    def get_by_username(cls, username):
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        c.execute('SELECT * FROM users WHERE username = ?', (username,))
+        user = c.fetchone()
+        conn.close()
+        if user:
+            return cls(user[0], user[1], user[2], 
+                      eval(user[3]) if user[3] else [],
+                      eval(user[4]) if user[4] else [])
+        return None
+
+    def update_chat_history(self, new_messages):
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        updated_history = self.chat_history + new_messages
+        c.execute('UPDATE users SET previous_chat_history = ? WHERE id = ?',
+                 (str(updated_history), self.id))
+        conn.commit()
+        conn.close()    
+
+    def update_products_bought(self, new_products):
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        updated_products = self.products_bought + new_products
+        c.execute('UPDATE users SET previous_products_bought = ? WHERE id = ?',
+                 (str(updated_products), self.id))
+        conn.commit()
+        conn.close()    
+        
 
 # --- AI Agent Setup ---
+# Load the LLM model from Groq
 os.environ["GROQ_API_KEY"] = st.secrets["GROQ_API_KEY"]
 llm = ChatGroq(
     temperature=0.1,
@@ -60,10 +94,12 @@ llm = ChatGroq(
     api_key=st.secrets["GROQ_API_KEY"],
 )
 
+# Load the HuggingFace Embeddings
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
+# Load and process CSV data
 @st.cache_resource
-def load_data(data_version):
+def load_data():
     loader = CSVLoader(file_path="electronics_products.csv")
     docs = loader.load()
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
@@ -71,86 +107,88 @@ def load_data(data_version):
     vectorstore = InMemoryVectorStore.from_documents(documents=splits, embedding=embeddings)
     return vectorstore.as_retriever()
 
-# Initialize with default data version
-retriever = load_data(0)
+retriever = load_data()
 
-def get_company_settings():
-    conn = sqlite3.connect('users.db')
-    c = conn.cursor()
-    c.execute('SELECT * FROM company_settings WHERE id=1')
-    settings = c.fetchone()
-    conn.close()
-    return {
-        'company_name': settings[1],
-        'company_business': settings[2],
-        'agent_name': settings[3],
-        'key_features': settings[4]
-    }
+def retrieve_query(query: str):
+    """Retrieves documents related to the query."""
+    return retriever.get_relevant_documents(query)
 
-# --- Admin Dashboard ---
-def admin_dashboard():
-    st.header("Admin Dashboard")
-    
-    # Company Settings Form
-    with st.expander("Company Settings"):
-        settings = get_company_settings()
-        
-        with st.form("company_settings"):
-            new_name = st.text_input("Company Name", value=settings['company_name'])
-            new_business = st.text_input("Business", value=settings['company_business'])
-            new_agent = st.text_input("Agent Name", value=settings['agent_name'])
-            new_features = st.text_area("Key Features", value=settings['key_features'])
-            
-            if st.form_submit_button("Save Settings"):
-                conn = sqlite3.connect('users.db')
-                c = conn.cursor()
-                c.execute('''UPDATE company_settings SET
-                            company_name=?, company_business=?, agent_name=?, key_features=?
-                            WHERE id=1''',
-                         (new_name, new_business, new_agent, new_features))
-                conn.commit()
-                conn.close()
-                st.success("Settings updated!")
+tool = Tool(
+    name="retriever",
+    func=retrieve_query,
+    description="Useful for retrieving product information"
+)
 
-    # Product Management
-    with st.expander("Product Management"):
-        st.subheader("Update Product Catalog")
-        uploaded_file = st.file_uploader("Upload new CSV", type="csv")
-        
-        if uploaded_file is not None:
-            # Save the uploaded file
-            with open("electronics_products.csv", "wb") as f:
-                f.write(uploaded_file.getbuffer())
-            # Update data version to refresh cache
-            st.session_state.data_version = st.session_state.get("data_version", 0) + 1
-            st.success("Product catalog updated!")
+# Agent setup
+# System prompt template
+system_prompt = """
+      You are {agent_name}, the AI Sales Assistant for {company_name} ({company_business}).
+
+      Company Profile:
+      - Company Name: {company_name}
+      - Business: {company_business}
+      - Key Features: {key_features}
+
+      Product Availability:
+      - Only recommend and discuss products listed in the provided in document.
+      - Do not suggest unavailable or out-of-stock products.
+      - Always verify product availability before making recommendations.
+
+      Conversation Flow:
+      1. Introduction
+      2. Qualification
+      3. Understanding Needs
+      4. Needs Analysis
+      5. Solution Presentation (Only recommend available products)
+      6. Confirmation
+      7. If the prospect agrees to purchase, thank them and provide the payment link: https://www.example.com/payment
+
+      Guidelines:
+      - Maintain natural, professional conversations
+      - Follow company policies
+      - Be helpful and polite
+      - Always cross-check product recommendations with the available inventory in the CSV document
+      """
+
+# Define the company and agent details
+company_name = "TechElectronics"
+company_business = "Consumer Electronics Retailer"
+agent_name = "Alex"
+key_features = "Cutting-edge technology, Competitive pricing, Excellent customer service"
+
+# Format the system prompt with the company and agent details
+formatted_system_prompt = system_prompt.format(
+    agent_name=agent_name,
+    company_name=company_name,
+    company_business=company_business,
+    key_features=key_features
+)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", formatted_system_prompt),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("human", "{input}"),
+    MessagesPlaceholder(variable_name="agent_scratchpad")
+])
+
+tools = [tool]
+agent = create_tool_calling_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
-    if st.button("Back to Main"):
-        st.session_state.show_admin = False
-        st.rerun()
 
 # --- Streamlit UI ---
 def main():
-    st.set_page_config(page_title="AI Sales Assistant", layout="wide")
+    st.title(f"{company_name} AI Sales Assistant 🤖")
     
-    # Initialize session states
+    # Initialize session state
     if 'user' not in st.session_state:
         st.session_state.user = None
         st.session_state.chat_history = []
-    if 'show_admin' not in st.session_state:
-        st.session_state.show_admin = False
-    if 'data_version' not in st.session_state:
-        st.session_state.data_version = 0
-
-    # Check admin status first
-    if st.session_state.show_admin:
-        admin_dashboard()
-        return
-
+    
     # Authentication
     if not st.session_state.user:
         st.header("Login/Register")
-        tab1, tab2, tab3 = st.tabs(["Login", "Register", "Admin"])
+        tab1, tab2 = st.tabs(["Login", "Register"])
         
         with tab1:
             with st.form("Login"):
@@ -159,6 +197,7 @@ def main():
                 if st.form_submit_button("Login"):
                     user = User.get_by_username(username)
                     if user and check_password_hash(user.password, password):
+                        # If valid, the user is stored in st.session_state.user and their chat history is loaded.
                         st.session_state.user = user
                         st.session_state.chat_history = user.chat_history
                         st.rerun()
@@ -177,101 +216,49 @@ def main():
                         st.session_state.user = user
                         st.session_state.chat_history = []
                         st.rerun()
-        
-        with tab3:
-            with st.form("Admin Login"):
-                admin_key = st.text_input("Admin Key", type="password")
-                if st.form_submit_button("Enter Admin Dashboard"):
-                    if admin_key == st.secrets.get("ADMIN_KEY", "default_admin_key"):
-                        st.session_state.show_admin = True
-                        st.rerun()
-                    else:
-                        st.error("Invalid Admin Key")
 
     else:
-        # Main Chat Interface
-        settings = get_company_settings()
-        st.title(f"{settings['company_name']} AI Sales Assistant 🤖")
+        # Chat Interface
+        st.header(f"Welcome to {company_name}, {st.session_state.user.username}😊!")
+        st.subheader("Chat with our AI Sales Assistant")
         
-        st.header(f"Welcome to {settings['company_name']}, {st.session_state.user.username} 😊!")
-        
-        # Reload data with current version
-        global retriever
-        retriever = load_data(st.session_state.data_version)
-        
-        # Dynamic system prompt
-        system_prompt = f"""
-        You are {settings['agent_name']}, the AI Sales Assistant for {settings['company_name']} ({settings['company_business']}).
-
-        Company Profile:
-        - Company Name: {settings['company_name']}
-        - Business: {settings['company_business']}
-        - Key Features: {settings['key_features']}
-
-        Product Availability:
-        - Only recommend and discuss products listed in the provided document.
-        - Do not suggest unavailable or out-of-stock products.
-        - Always verify product availability before making recommendations.
-
-        Conversation Flow:
-        1. Introduction
-        2. Qualification
-        3. Understanding Needs
-        4. Needs Analysis
-        5. Solution Presentation (Only recommend available products)
-        6. Confirmation
-        7. If the prospect agrees to purchase, thank them and provide the payment link: https://www.example.com/payment
+        # # Display chat history
+        # for msg in st.session_state.chat_history:
+        #     if msg["type"] == "human":
+        #         with st.chat_message("user"):
+        #             st.write(msg["content"])
+        #     else:
+        #         with st.chat_message("assistant"):
+        #             st.write(msg["content"])
 
-        Guidelines:
-        - Maintain natural, professional conversations
-        - Follow company policies
-        - Be helpful and polite
-        - Always cross-check product recommendations with the available inventory in the CSV document
-        """
-
-        # Agent setup with dynamic prompt
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", system_prompt),
-            MessagesPlaceholder(variable_name="chat_history"),
-            ("human", "{input}"),
-            MessagesPlaceholder(variable_name="agent_scratchpad")
-        ])
-
-        tool = Tool(
-            name="retriever",
-            func=lambda q: retriever.get_relevant_documents(q),
-            description="Useful for retrieving product information"
-        )
-
-        agent = create_tool_calling_agent(llm, [tool], prompt)
-        agent_executor = AgentExecutor(agent=agent, tools=[tool], verbose=True)
-
-        # Chat handling
-        if prompt_input := st.chat_input("Type your message here..."):
-            # Add user message
+        if prompt := st.chat_input("Type you Message here..."):
+            #Add user message to chat
             with st.chat_message("user"):
-                st.write(prompt_input)
+                st.write(prompt)
 
             # Get AI response
             with st.chat_message("assistant"):
                 response = agent_executor.invoke({
-                    "input": prompt_input,
+                    "input": prompt,
                     "chat_history": [HumanMessage(content=msg["content"]) if msg["type"] == "human" else AIMessage(content=msg["content"]) 
                                    for msg in st.session_state.chat_history]
                 })["output"]
                 st.write(response)
                 
+                # Check if payment link is provided
                 if "https://www.example.com/payment" in response:
                     st.session_state.user.update_products_bought(["Latest Product"])
-                    st.success("Product added to your purchases!")
-
-            # Update chat history
+                    st.success("Product added to your purchases!")    
+                    
+            # Update chat history in database
             new_messages = [
-                {"type": "human", "content": prompt_input},
+                {"type": "human", "content": prompt},
                 {"type": "ai", "content": response}
             ]
+            # Both the user’s message and the assistant’s reply are appended to the persistent chat history 
+            # (both in session and in the database), ensuring conversation continuity.
             st.session_state.user.update_chat_history(new_messages)
             st.session_state.chat_history += new_messages
 
 if __name__ == "__main__":
-    main()
+    main()