Update app.py

app.py

@@ -2,6 +2,7 @@ import os
 import sqlite3
 import streamlit as st
 from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime
 
 from langchain_groq import ChatGroq
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -46,11 +47,13 @@ def init_db():
                   features TEXT NOT NULL,
                   stock INTEGER NOT NULL DEFAULT 0)''')
     
-    # Check and update schema if needed
-    c.execute("PRAGMA table_info(products)")
-    columns = [column[1] for column in c.fetchall()]
-    if 'stock' not in columns:
-        c.execute('ALTER TABLE products ADD COLUMN stock INTEGER NOT NULL DEFAULT 0')
+    # Inventory log table
+    c.execute('''CREATE TABLE IF NOT EXISTS inventory_log
+                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                  timestamp TEXT NOT NULL,
+                  product_name TEXT NOT NULL,
+                  found INTEGER NOT NULL,
+                  username TEXT)''')
     
     # Insert default company settings if empty
     c.execute('SELECT COUNT(*) FROM company_settings')
@@ -68,8 +71,40 @@ def init_db():
 
 conn = init_db()
 
-# --- Admin Classes ---
+# --- Inventory Management Functions ---
+def log_inventory_access(product_name: str, found: bool, username: str = None):
+    """Log all inventory access attempts"""
+    c = conn.cursor()
+    c.execute('''INSERT INTO inventory_log 
+                 (timestamp, product_name, found, username)
+                 VALUES (?, ?, ?, ?)''',
+              (datetime.now().isoformat(), product_name, int(found), username))
+    conn.commit()
+
+def validate_product_in_inventory(product_name: str) -> bool:
+    """Check if product exists and is in stock"""
+    c = conn.cursor()
+    c.execute('''SELECT id FROM products 
+                 WHERE LOWER(name) LIKE LOWER(?) AND stock > 0''',
+              (f'%{product_name}%',))
+    return c.fetchone() is not None
 
+def get_inventory_report():
+    """Generate inventory report for admin"""
+    c = conn.cursor()
+    c.execute('''SELECT name, category, price, stock 
+                 FROM products ORDER BY category, name''')
+    return c.fetchall()
+
+def get_inventory_alerts():
+    """Get low stock alerts"""
+    c = conn.cursor()
+    c.execute('''SELECT name, stock FROM products 
+                 WHERE stock <= 3 AND stock > 0
+                 ORDER BY stock ASC''')
+    return c.fetchall()
+
+# --- Admin Classes ---
 class Company:
     @staticmethod
     def get_settings():
@@ -93,6 +128,15 @@ class Product:
         c.execute('SELECT * FROM products')
         return c.fetchall()
 
+    @staticmethod
+    def search(query):
+        c = conn.cursor()
+        c.execute('''SELECT * FROM products 
+                     WHERE LOWER(name) LIKE LOWER(?) 
+                     OR LOWER(category) LIKE LOWER(?)''',
+                  (f'%{query}%', f'%{query}%'))
+        return c.fetchall()
+
     @staticmethod
     def get_by_id(product_id):
         c = conn.cursor()
@@ -132,21 +176,17 @@ class 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)
 
     @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 [],
@@ -155,23 +195,19 @@ class User:
 
     def update_chat_history(self, new_messages):
         updated_history = self.chat_history + new_messages
-        conn = sqlite3.connect('users.db')
         c = conn.cursor()
         c.execute('UPDATE users SET previous_chat_history = ? WHERE id = ?',
                  (str(updated_history), self.id))
         conn.commit()
-        conn.close()
-        self.chat_history = updated_history  # Update in-memory
+        self.chat_history = updated_history
 
     def update_products_bought(self, new_products):
         updated_products = self.products_bought + new_products
-        conn = sqlite3.connect('users.db')
         c = conn.cursor()
         c.execute('UPDATE users SET previous_products_bought = ? WHERE id = ?',
                  (str(updated_products), self.id))
         conn.commit()
-        conn.close()
-        self.products_bought = updated_products  # Update in-memory
+        self.products_bought = updated_products
 
 # --- AI Setup ---
 os.environ["GROQ_API_KEY"] = st.secrets["GROQ_API_KEY"]
@@ -200,14 +236,23 @@ def load_data():
 retriever = load_data()
 
 def retrieve_query(query: str):
+    """Enhanced product retrieval with strict inventory checks"""
     docs = retriever.get_relevant_documents(query)
-    st.session_state.last_retrieved_docs = docs
-    return docs
+    valid_docs = [doc for doc in docs if doc.metadata.get('stock', 0) > 0]
+    
+    if not valid_docs:
+        return [Document(
+            page_content=f"No matching in-stock products found for '{query}'",
+            metadata={"id": -1, "stock": 0}
+        )]
+    
+    st.session_state.last_retrieved_docs = valid_docs
+    return valid_docs
 
 tool = Tool(
     name="product_retriever",
     func=retrieve_query,
-    description="Useful for retrieving product information including current stock levels"
+    description="Useful for retrieving product information from CURRENT INVENTORY only"
 )
 
 # --- Admin Dashboard ---
@@ -266,13 +311,39 @@ def admin_dashboard():
                     st.rerun()
         else:
             st.info("No products found in database")
+    
+    with st.expander("Inventory Reports"):
+        st.subheader("Current Inventory Status")
+        inventory = get_inventory_report()
+        if inventory:
+            st.table(inventory)
+        else:
+            st.warning("No inventory data available")
+        
+        st.subheader("Low Stock Alerts")
+        alerts = get_inventory_alerts()
+        if alerts:
+            for item in alerts:
+                st.warning(f"{item[0]} - Only {item[1]} left!")
+        else:
+            st.info("No low stock alerts")
+        
+        st.subheader("Inventory Access Logs")
+        c = conn.cursor()
+        c.execute('''SELECT timestamp, product_name, found, username 
+                     FROM inventory_log ORDER BY timestamp DESC LIMIT 100''')
+        logs = c.fetchall()
+        if logs:
+            st.table(logs)
+        else:
+            st.info("No inventory access logs yet")
 
 # --- Main App ---
 def main():
     company_settings = Company.get_settings()
     company_name = company_settings[1]
 
-    st.title("AI Sales Assistant 🤖")
+    st.title(f"{company_name} AI Sales Assistant 🤖")
     
     if 'user' not in st.session_state:
         st.session_state.user = None
@@ -282,7 +353,7 @@ def main():
     
     # Authentication
     if not st.session_state.user and not st.session_state.admin_mode:
-        st.header("Login/Register Admin")
+        st.header("Login/Register")
         tab1, tab2, tab3 = st.tabs(["Login", "Register", "Admin"])
         
         with tab1:
@@ -329,8 +400,8 @@ def main():
 
     else:
         # 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, {st.session_state.user.username}!")
+        st.caption(f"You're chatting with {company_settings[3]}, your AI sales assistant")
 
         # Display Chat History
         for msg in st.session_state.chat_history:
@@ -346,67 +417,31 @@ def main():
         current_products = "\n".join([f"- {p[1]} (${p[3]}, Stock: {p[6]})" for p in Product.get_all()])
         
         system_prompt = f"""
-        You are {company_settings[3]}, the AI Sales Assistant for {company_settings[1]} ({company_settings[2]}). Your primary role is to assist customers with product inquiries, make appropriate recommendations, and facilitate purchases while strictly adhering to company policies.
-
-        ## Company Profile
-        - Company Name: {company_settings[1]}
-        - Business Type: {company_settings[2]}
+        STRICT INVENTORY POLICY:
+        - You MUST ONLY recommend products that exist in our CURRENT INVENTORY
+        - NEVER suggest, mention, or describe products not in our database
+        - If asked for unavailable items, respond: "I apologize, we don't currently carry that product."
+        - For out-of-stock items, clearly state they're unavailable
+        - ALWAYS check stock levels before recommending products
+
+        COMPANY PROFILE:
+        - Name: {company_settings[1]}
+        - Business: {company_settings[2]}
+        - Agent: {company_settings[3]}
         - Key Features: {company_settings[4]}
-        - Agent Name: {company_settings[3]}
-
-        ## Inventory Management Policy
-        1. **Stock Verification**:
-           - ALWAYS check current stock before recommending any product
-           - Never suggest out-of-stock items (stock = 0)
-           - For low stock items (stock ≤ 3), mention: "Only [X] left in stock!"
-        
-        2. **Product Recommendations**:
-           - Only recommend products from our current inventory
-           - If asked for unavailable items, respond with: "I apologize, we don't currently carry that item. As a {company_settings[2]}, we specialize in [relevant products]. May I suggest [alternative]?"
-           - When suggesting alternatives, ensure they're in stock
-
-        3. **Purchase Process**:
-           - Confirm product availability before purchase
-           - Generate payment link only after stock verification
-           - Update inventory immediately after successful purchase
-
-        ## Conversation Flow Examples
-
-        ### 1. Greeting & Need Assessment
-        User: "Hi, I need a new laptop"
-        You: "Hello! I'd be happy to help you find the perfect laptop. Could you tell me what you'll primarily be using it for and your budget range?"
-
-        ### 2. Product Recommendation (In-Stock)
-        User: "I need a gaming laptop under $1500"
-        You: "We have the XYZ Gaming Laptop available for $1399 (3 in stock). It features [key specs]. Would you like more details?"
-
-        ### 3. Product Recommendation (Out-of-Stock)
-        User: "Do you have ABC Smartphone?"
-        You: "I apologize, the ABC Smartphone is currently out of stock. However, we have the DEF Smartphone with similar features available for $599 (5 in stock). Would you like me to tell you more about it?"
-
-        ### 4. Handling Off-Topic Requests
-        User: "Do you sell snacks?"
-        You: "I apologize, as a {company_settings[2]}, we specialize in [tech products]. We don't carry food items. Is there a tech product I can assist you with today?"
-
-        ### 5. Purchase Process
-        User: "I want to buy the XYZ Laptop"
-        You: "Great choice! The XYZ Laptop is available for $1399 (2 in stock). I can generate a secure payment link for you. Would you like to proceed with the purchase? [https://www.example.com/payment]"
-
-        ## Communication Guidelines
-        - Tone: Professional yet friendly (like a knowledgeable salesperson)
-        - Language: Clear, concise, avoid technical jargon unless requested
-        - Emojis: Use sparingly (1-2 per message max)
-        - Branding: Consistently reference {company_settings[1]} when appropriate
 
-        ## Current Inventory Status
+        CURRENT INVENTORY:
         {current_products}
 
-        ## Important Reminders
-        1. NEVER recommend products not in our inventory
-        2. ALWAYS verify stock before discussing any product
-        3. Update inventory immediately after purchases
-        4. Politely redirect off-topic requests to our product offerings
-        5. For complex queries, offer to connect with human support
+        RESPONSE RULES:
+        1. First verify product exists in inventory before discussing
+        2. For unavailable products:
+           - Don't suggest alternatives unless they exist in inventory
+           - Don't make up product details
+        3. For purchases:
+           - Verify stock is available
+           - Update inventory after purchase
+           - Generate payment link only when stock is confirmed
         """
 
         prompt = ChatPromptTemplate.from_messages([
@@ -421,20 +456,35 @@ def main():
         agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
         if prompt_input := st.chat_input("Type your message here..."):
+            # Log inventory access attempt
+            log_inventory_access(
+                product_name=prompt_input,
+                found=validate_product_in_inventory(prompt_input),
+                username=st.session_state.user.username
+            )
+
             with st.chat_message("user"):
                 st.write(prompt_input)
 
             with st.chat_message("assistant"):
                 response = agent_executor.invoke({
                     "input": prompt_input,
-                    "chat_history": [HumanMessage(content=msg["content"]) if msg["type"] == "human" else AIMessage(content=msg["content"]) 
+                    "chat_history": [HumanMessage(content=msg["content"]) if msg["type"] == "human" 
+                                   else AIMessage(content=msg["content"]) 
                                    for msg in st.session_state.chat_history]
                 })["output"]
+                
+                # Post-process response to ensure inventory compliance
+                if "last_retrieved_docs" in st.session_state:
+                    if st.session_state.last_retrieved_docs[0].metadata.get("id") == -1:
+                        response = f"I apologize, we don't currently carry that product in our inventory."
+                    elif not st.session_state.last_retrieved_docs:
+                        response = f"I couldn't find that product in our current inventory."
+                
                 st.write(response)
                 
                 # Handle inventory update on purchase
                 if "https://www.example.com/payment" in response:
-                    # Extract product name from the agent's response
                     product_name = None
                     if "proceed with the purchase of" in response:
                         start = response.find("proceed with the purchase of") + len("proceed with the purchase of")
@@ -442,19 +492,16 @@ def main():
                         product_name = response[start:end].strip()
                     
                     if product_name:
-                        # Retrieve current product details
                         docs = retrieve_query(product_name)
-                        if docs:
+                        if docs and docs[0].metadata.get("id") != -1:
                             product_doc = docs[0]
                             product_id = product_doc.metadata.get("id")
                             current_stock = product_doc.metadata.get("stock")
                             
                             if product_id and current_stock > 0:
                                 try:
-                                    conn = sqlite3.connect('users.db')
-                                    c = conn.cursor()
-                                    
                                     # Verify current stock
+                                    c = conn.cursor()
                                     c.execute('SELECT stock FROM products WHERE id = ?', (product_id,))
                                     actual_stock = c.fetchone()[0]
                                     
@@ -464,38 +511,23 @@ def main():
                                                 (actual_stock - 1, product_id))
                                         
                                         # Update user's purchase history
-                                        c.execute('SELECT previous_products_bought FROM users WHERE id = ?', 
-                                                (st.session_state.user.id,))
-                                        current_purchases = c.fetchone()[0]
-                                        
-                                        updated_purchases = eval(current_purchases) + [product_name] if current_purchases else [product_name]
-                                        
-                                        c.execute('UPDATE users SET previous_products_bought = ? WHERE id = ?',
-                                                (str(updated_purchases), st.session_state.user.id))
+                                        st.session_state.user.products_bought.append(product_name)
+                                        st.session_state.user.update_products_bought([product_name])
                                         
                                         conn.commit()
-                                        st.session_state.user.products_bought.append(product_name)
                                         st.success(f"Successfully purchased {product_name}! Stock updated.")
                                         load_data.clear()
                                         
                                         # Check for low stock
-                                        if (actual_stock - 1) <= 3 and (actual_stock - 1) > 0:
-                                            st.warning(f"Low stock alert: Only {actual_stock - 1} units of {product_name} remaining!")
+                                        if (actual_stock - 1) <= 3:
+                                            st.warning(f"Low stock alert: Only {actual_stock - 1} units remaining!")
                                     else:
                                         st.error(f"Sorry, {product_name} is now out of stock!")
                                 except Exception as e:
                                     st.error(f"Error processing purchase: {str(e)}")
-                                    if conn:
-                                        conn.rollback()
+                                    conn.rollback()
                                 finally:
-                                    if conn:
-                                        conn.close()
-                            else:
-                                st.error("Product is out of stock or not found in the inventory.")
-                        else:
-                            st.error("Could not retrieve product details. Please try again.")
-                    else:
-                        st.error("Please specify which product you'd like to purchase.")
+                                    c.close()
 
             new_messages = [
                 {"type": "human", "content": prompt_input},