Update app.py

app.py

@@ -1,10 +1,10 @@
 import os
 import sqlite3
 import streamlit as st
-from datetime import datetime
 from werkzeug.security import generate_password_hash, check_password_hash
 from langchain_groq import ChatGroq
 from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.document_loaders.csv_loader import CSVLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_core.vectorstores import InMemoryVectorStore
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
@@ -12,119 +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('app.db', check_same_thread=False)
+    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,
-                  is_admin BOOLEAN DEFAULT 0,
                   previous_chat_history TEXT,
                   previous_products_bought TEXT)''')
-    
-    # Products Table
-    c.execute('''CREATE TABLE IF NOT EXISTS products
-                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
-                  name TEXT NOT NULL,
-                  description TEXT,
-                  price REAL,
-                  stock INTEGER,
-                  features TEXT,
-                  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
-    
     conn.commit()
     return conn
 
 conn = init_db()
 
-# --- Data Models ---
+
 class User:
-    def __init__(self, id, username, password, is_admin=False, chat_history=None, products_bought=None):
+    def __init__(self, id, username, password, chat_history = None, products_bought = None):
         self.id = id
         self.username = username
         self.password = password
-        self.is_admin = is_admin
         self.chat_history = chat_history or []
         self.products_bought = products_bought or []
 
+    # To register a new user
     @classmethod
-    def create(cls, username, password, is_admin=False):
+    def create(cls, username, password):
         hashed_pw = generate_password_hash(password)
+        conn = sqlite3.connect('users.db')
         c = conn.cursor()
-        try:
-            c.execute('INSERT INTO users (username, password, is_admin) VALUES (?, ?, ?)',
-                     (username, hashed_pw, int(is_admin)))
-            conn.commit()
-            return cls(c.lastrowid, username, hashed_pw, is_admin)
-        except sqlite3.IntegrityError:
-            raise ValueError("Username already exists")
+        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], bool(user[3]),
-                      eval(user[4]) if user[4] else [],
-                      eval(user[5]) if user[5] else [])
+            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()
-
-class ProductManager:
-    @staticmethod
-    @st.cache_data(ttl=60, show_spinner=False)
-    def get_all_products():
-        c = conn.cursor()
-        c.execute('SELECT * FROM products')
-        return c.fetchall()
-
-    @staticmethod
-    def add_product(name, description, price, stock, features):
-        c = conn.cursor()
-        c.execute('''INSERT INTO products 
-                     (name, description, price, stock, features)
-                     VALUES (?, ?, ?, ?, ?)''',
-                 (name, description, price, stock, str(features)))
-        conn.commit()
-        st.cache_data.clear()
-
-    @staticmethod
-    def update_product(product_id, **kwargs):
-        c = conn.cursor()
-        set_clause = ', '.join([f"{k} = ?" for k in kwargs])
-        values = list(kwargs.values()) + [product_id]
-        c.execute(f'UPDATE products SET {set_clause}, updated_at = CURRENT_TIMESTAMP WHERE id = ?', values)
-        conn.commit()
-        st.cache_data.clear()
-
-    @staticmethod
-    def delete_product(product_id):
-        c = conn.cursor()
-        c.execute('DELETE FROM products WHERE id = ?', (product_id,))
-        conn.commit()
-        st.cache_data.clear()
+        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,
@@ -132,148 +94,89 @@ llm = ChatGroq(
     api_key=st.secrets["GROQ_API_KEY"],
 )
 
+# Load the HuggingFace Embeddings
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
-@st.cache_resource(show_spinner=False)
-def load_product_data():
+# Load and process CSV data
+@st.cache_resource
+def load_data():
+    loader = CSVLoader(file_path="electronics_products.csv")
+    docs = loader.load()
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
-    products = ProductManager.get_all_products()
-    
-    # Convert products to document format
-    docs = [f"Name: {p[1]}\nDescription: {p[2]}\nPrice: ${p[3]}\nStock: {p[4]}\nFeatures: {p[5]}" 
-            for p in products]
-    
     splits = text_splitter.split_documents(docs)
     vectorstore = InMemoryVectorStore.from_documents(documents=splits, embedding=embeddings)
     return vectorstore.as_retriever()
 
-retriever = load_product_data()
+retriever = load_data()
 
 def retrieve_query(query: str):
+    """Retrieves documents related to the query."""
     return retriever.get_relevant_documents(query)
 
 tool = Tool(
-    name="product_retriever",
+    name="retriever",
     func=retrieve_query,
-    description="Access real-time product information including pricing, availability, and features"
+    description="Useful for retrieving product information"
 )
 
-# Agent Configuration
+# Agent setup
+# System prompt template
 system_prompt = """
-You are {agent_name}, the AI Sales Assistant for {company_name} ({company_business}).
-
-Real-Time Product Updates:
-- Current Inventory: {product_count} items
-- Last Updated: {last_updated}
-
-Guidelines:
-1. Always verify product availability before suggesting
-2. Mention price changes immediately
-3. Update recommendations based on stock levels
-4. Alert users about restocked items
+      You are {agent_name}, the AI Sales Assistant for {company_name} ({company_business}).
 
-Conversation Flow:
-1. Introduction
-2. Qualification
-3. Understanding Needs
-4. Needs Analysis
-5. Solution Presentation
-6. Confirmation
-7. If the prospect agrees to purchase, thank them and provide the payment link: https://www.example.com/payment
+      Company Profile:
+      - Company Name: {company_name}
+      - Business: {company_business}
+      - Key Features: {key_features}
 
-Guidelines:
-- Maintain natural, professional conversations
-- Follow company policies
-- Be helpful and polite
-"""
+      Conversation Flow:
+      1. Introduction
+      2. Qualification
+      3. Understanding Needs
+      4. Needs Analysis
+      5. Solution Presentation
+      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
+      """
+# 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"
 
-def get_agent_prompt():
-    products = ProductManager.get_all_products()
-    return system_prompt.format(
-        agent_name=agent_name,
-        company_name=company_name,
-        company_business=company_business,
-        product_count=len(products),
-        last_updated=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    )
+# 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", get_agent_prompt()),
+    ("system", formatted_system_prompt),
     MessagesPlaceholder(variable_name="chat_history"),
     ("human", "{input}"),
     MessagesPlaceholder(variable_name="agent_scratchpad")
 ])
 
-agent = create_tool_calling_agent(llm, [tool], prompt)
-agent_executor = AgentExecutor(agent=agent, tools=[tool], verbose=True)
+tools = [tool]
+agent = create_tool_calling_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
-# --- Streamlit UI ---
-def admin_dashboard():
-    st.header("Product Management Dashboard")
-    
-    tab1, tab2, tab3 = st.tabs(["Add Product", "Edit Product", "Inventory"])
-    
-    with tab1:
-        with st.form("Add Product"):
-            name = st.text_input("Product Name")
-            desc = st.text_area("Description")
-            price = st.number_input("Price", min_value=0.0)
-            stock = st.number_input("Stock", min_value=0)
-            features = st.text_area("Features (comma-separated)")
-            if st.form_submit_button("Add Product"):
-                ProductManager.add_product(name, desc, price, stock, features)
-                st.success("Product added successfully!")
-    
-    with tab2:
-        products = ProductManager.get_all_products()
-        selected = st.selectbox("Select Product", products, format_func=lambda x: x[1])
-        if selected:
-            with st.form("Edit Product"):
-                new_name = st.text_input("Name", value=selected[1])
-                new_desc = st.text_area("Description", value=selected[2])
-                new_price = st.number_input("Price", value=selected[3])
-                new_stock = st.number_input("Stock", value=selected[4])
-                new_features = st.text_area("Features", value=selected[5])
-                if st.form_submit_button("Update"):
-                    ProductManager.update_product(selected[0],
-                        name=new_name,
-                        description=new_desc,
-                        price=new_price,
-                        stock=new_stock,
-                        features=new_features
-                    )
-                    st.success("Product updated!")
-    
-    with tab3:
-        st.dataframe(
-            data=ProductManager.get_all_products(),
-            column_config={
-                "0": "ID",
-                "1": "Name", 
-                "2": "Description",
-                "3": "Price",
-                "4": "Stock",
-                "5": "Features",
-                "6": "Created",
-                "7": "Updated"
-            },
-            use_container_width=True
-        )
-          
 
+# --- Streamlit UI ---
 def main():
     st.title(f"{company_name} AI Sales Assistant 🤖")
     
+    # Initialize session state
     if 'user' not in st.session_state:
-        st.session_state.update({
-            'user': None,
-            'chat_history': [],
-            'product_update_flag': False
-        })
+        st.session_state.user = None
+        st.session_state.chat_history = []
     
     # Authentication
     if not st.session_state.user:
@@ -287,66 +190,68 @@ 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()
+                    else:
+                        st.error("Invalid credentials")
         
         with tab2:
             with st.form("Register"):
                 new_user = st.text_input("New Username")
                 new_pass = st.text_input("New Password", type="password")
                 if st.form_submit_button("Register"):
-                    try:
+                    if User.get_by_username(new_user):
+                        st.error("Username already exists")
+                    else:
                         user = User.create(new_user, new_pass)
                         st.session_state.user = user
+                        st.session_state.chat_history = []
                         st.rerun()
-                    except ValueError as e:
-                        st.error(str(e))
-    
+
     else:
-        if st.session_state.user.is_admin:
-            admin_dashboard()
-            st.divider()
-        
         # Chat Interface
-        st.header(f"Welcome {st.session_state.user.username}{' 👑' if st.session_state.user.is_admin else ''}")
+        st.header(f"Welcome to {company_name}, {st.session_state.user.username}😊!")
+        st.subheader("Chat with our AI Sales Assistant")
         
-        # Chat History
-        for msg in st.session_state.chat_history:
-            avatar = "🤖" if msg["type"] == "ai" else None
-            with st.chat_message(msg["type"], avatar=avatar):
-                st.write(msg["content"])
-        
-        # Input Handling
-        if prompt := st.chat_input("How can I help you today?"):
-            # User Message
+        # # 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"])
+
+        if prompt := st.chat_input("Type you Message here..."):
+            #Add user message to chat
             with st.chat_message("user"):
                 st.write(prompt)
-            
-            # AI Response
-            with st.chat_message("assistant", avatar="🤖"):
+
+            # Get AI response
+            with st.chat_message("assistant"):
                 response = agent_executor.invoke({
                     "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
-                    ]
+                    "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("Purchase recorded!")
-            
-            # Update History
+                    st.success("Product added to your purchases!")    
+                    
+            # Update chat history in database
             new_messages = [
                 {"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__":
-    # admin_dashboard()
-    main()
+    main()