Update app.py

app.py

@@ -12,81 +12,47 @@ 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:
-    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()    
-        
+    # ... (existing User class remains unchanged) ...
 
 # --- AI Agent Setup ---
-# Load the LLM model from Groq
 os.environ["GROQ_API_KEY"] = st.secrets["GROQ_API_KEY"]
 llm = ChatGroq(
     temperature=0.1,
@@ -94,12 +60,10 @@ 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():
+def load_data(data_version):
     loader = CSVLoader(file_path="electronics_products.csv")
     docs = loader.load()
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
@@ -107,88 +71,86 @@ def load_data():
     vectorstore = InMemoryVectorStore.from_documents(documents=splits, embedding=embeddings)
     return vectorstore.as_retriever()
 
-retriever = load_data()
-
-def retrieve_query(query: str):
-    """Retrieves documents related to the query."""
-    return retriever.get_relevant_documents(query)
-
-tool = Tool(
-    name="retriever",
-    func=retrieve_query,
-    description="Useful for retrieving product information"
-)
-
-# 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"
+# Initialize with default data version
+retriever = load_data(0)
 
-# 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
-)
+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]
+    }
 
-prompt = ChatPromptTemplate.from_messages([
-    ("system", formatted_system_prompt),
-    MessagesPlaceholder(variable_name="chat_history"),
-    ("human", "{input}"),
-    MessagesPlaceholder(variable_name="agent_scratchpad")
-])
+# --- 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!")
 
-tools = [tool]
-agent = create_tool_calling_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+    # 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!")
 
+    if st.button("Back to Main"):
+        st.session_state.show_admin = False
+        st.rerun()
 
 # --- Streamlit UI ---
 def main():
-    st.title(f"{company_name} AI Sales Assistant 🤖")
+    st.set_page_config(page_title="AI Sales Assistant", layout="wide")
     
-    # Initialize session state
+    # Initialize session states
     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 = st.tabs(["Login", "Register"])
+        tab1, tab2, tab3 = st.tabs(["Login", "Register", "Admin"])
         
         with tab1:
             with st.form("Login"):
@@ -197,7 +159,6 @@ 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()
@@ -216,49 +177,101 @@ 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:
-        # Chat Interface
-        st.header(f"Welcome to {company_name}, {st.session_state.user.username}😊!")
-        st.subheader("Chat with our AI Sales Assistant")
+        # Main Chat Interface
+        settings = get_company_settings()
+        st.title(f"{settings['company_name']} AI Sales Assistant 🤖")
         
-        # # 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"])
+        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
 
-        if prompt := st.chat_input("Type you Message here..."):
-            #Add user message to chat
+        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
             with st.chat_message("user"):
-                st.write(prompt)
+                st.write(prompt_input)
 
             # Get AI response
             with st.chat_message("assistant"):
                 response = agent_executor.invoke({
-                    "input": prompt,
+                    "input": prompt_input,
                     "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 in database
+                    st.success("Product added to your purchases!")
+
+            # Update chat history
             new_messages = [
-                {"type": "human", "content": prompt},
+                {"type": "human", "content": prompt_input},
                 {"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()