Update app.py

app.py

@@ -1,6 +1,5 @@
 import streamlit as st
 import pandas as pd
-from langchain.tools import Tool
 from langchain.memory import ConversationBufferMemory
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain.agents import AgentExecutor, create_openai_functions_agent
@@ -9,18 +8,21 @@ from PIL import Image
 import PyPDF2
 import os
 import json
-from dotenv import load_dotenv
 from langchain.chains import LLMChain
 from langchain.prompts import PromptTemplate
+from langchain.agents import initialize_agent, Tool
+from langchain.agents.agent_types import AgentType
+from PIL import Image
+from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
 
+# Configure Google API
 genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
 
 # Initialize Gemini models
 llm_flash_exp = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")
-model_flash_think = genai.GenerativeModel('gemini-2.0-flash-think')
 
 class SmartShoppingAssistant:
     def __init__(self, products_df):
@@ -29,10 +31,14 @@ class SmartShoppingAssistant:
         self.setup_agent()
         
     def setup_agent(self):
+        """Set up the LangChain agent with necessary tools"""
         def search_products(query):
             try:
+                # Convert price columns to numeric if they exist
                 if 'RetailPrice' in self.df.columns:
                     self.df['RetailPrice'] = pd.to_numeric(self.df['RetailPrice'].str.replace('$', ''), errors='coerce')
+                
+                # Execute the query and format results
                 results = self.df.query(query)
                 return results.to_string() if not results.empty else "No products found matching your criteria."
             except Exception as e:
@@ -46,71 +52,80 @@ class SmartShoppingAssistant:
             )
         ]
         
-        # Define a prompt template for the agent
-        prompt_template = """
-        You are a shopping assistant. Use the tools provided to find products based on user queries.
-        {input}
-        """
-        
-        # Create a PromptTemplate and LLMChain to make the model compatible
-        prompt = PromptTemplate(input_variables=["input"], template=prompt_template)
-        llm_chain = LLMChain(llm=llm_flash_exp, prompt=prompt)
-
-        # Create the agent with the adapted chain
-        agent = create_openai_functions_agent(
-            llm=llm_chain,
-            tools=tools,
-            prompt=prompt_template
-        )
-        
-        self.agent_executor = AgentExecutor(
-            agent=agent,
+        # Initialize the agent
+        self.agent = initialize_agent(
             tools=tools,
             memory=self.memory,
+            llm=llm_flash_exp,
+            agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
             verbose=True
         )
     
     def process_natural_language_query(self, query):
+        """Process natural language query and return relevant products"""
         try:
-            product_list = json.dumps(self.df['ProductName'].tolist())
+            # Use Gemini to generate a structured query
             prompt = f"""
-            Convert this shopping request into multiple pandas query strings for a DataFrame with columns: 
+            Convert this shopping request into a pandas query string for a DataFrame with columns: 
             {', '.join(self.df.columns)}
             
             Shopping request: {query}
+
+            List of available products: {str(df['Product'].tolist())}
             
-            Available products: {product_list}
-            
-            Return only a list of valid pandas query strings, nothing else.
+            Return only the pandas query string, nothing else.
             """
             
-            response = model_flash_think.generate_content(prompt)
-            queries = response.text.strip().split('\n')
-            
-            results = []
-            for q in queries:
-                if q.strip():
-                    result = self.agent_executor.invoke({"input": f"Execute this query and return matching products: {q.strip()}"})
-                    results.append(result['output'])
+            response = llm_flash_exp.predict(prompt)
+            structured_query = response.strip()
             
-            return "\n\n".join(results) if results else "No matching products found."
+            # Execute the query through the agent
+            result = self.agent.run(f"Execute this query and return matching products: {structured_query}")
+            return result
         except Exception as e:
             return f"Error processing query: {str(e)}"
+    
+    def extract_text_from_image(self, image):
+        """Extract text from uploaded image using Gemini"""
+        try:
+            # This will need OCR if the image contains text.
+            # For now, simulate the response for demonstration purposes.
+            return "Extracted text from image (OCR not implemented in this example)."
+        except Exception as e:
+            return f"Error processing image: {str(e)}"
+    
+    def extract_text_from_pdf(self, pdf_file):
+        """Extract text from uploaded PDF"""
+        try:
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+            return text
+        except Exception as e:
+            return f"Error processing PDF: {str(e)}"
 
 def main():
     st.set_page_config(page_title="Smart Shopping Assistant", layout="wide")
+    
     st.title("🛒 Smart Shopping Assistant")
     
+    # Load sample product data
     @st.cache_data
     def load_product_data():
+        # Replace this with your actual product data
         return pd.read_csv('supermarket2.csv')
     
     df = load_product_data()
     assistant = SmartShoppingAssistant(df)
     
+    # Sidebar for file uploads
     with st.sidebar:
         st.header("Upload Shopping List")
-        uploaded_file = st.file_uploader("Upload an image or PDF", type=['png', 'jpg', 'jpeg', 'pdf'])
+        uploaded_file = st.file_uploader(
+            "Upload an image or PDF of your shopping list",
+            type=['png', 'jpg', 'jpeg', 'pdf']
+        )
         
         if uploaded_file:
             if uploaded_file.type.startswith('image'):
@@ -120,19 +135,25 @@ def main():
                     with st.spinner("Processing image..."):
                         extracted_text = assistant.extract_text_from_image(image)
                         st.session_state.extracted_text = extracted_text
-                        st.success("Text extracted!")
+                        st.success("Text extracted! You can now search for these items.")
+            
             elif uploaded_file.type == 'application/pdf':
                 if st.button("Extract Items from PDF"):
                     with st.spinner("Processing PDF..."):
                         extracted_text = assistant.extract_text_from_pdf(uploaded_file)
                         st.session_state.extracted_text = extracted_text
-                        st.success("Text extracted!")
+                        st.success("Text extracted! You can now search for these items.")
     
+    # Main content area
     col1, col2 = st.columns([2, 1])
     
     with col1:
         st.header("Search Products")
-        query = st.text_area("Describe what you're looking for:", height=100, placeholder="Example: I need healthy breakfast cereals under $5")
+        query = st.text_area(
+            "Describe what you're looking for:",
+            height=100,
+            placeholder="Example: I need healthy breakfast cereals under $5"
+        )
         
         if hasattr(st.session_state, 'extracted_text'):
             st.write("Extracted text from upload:")
@@ -153,7 +174,9 @@ def main():
         st.header("Shopping Cart")
         if 'cart' not in st.session_state:
             st.session_state.cart = []
+        
+        # Display cart items (to be implemented)
         st.write("Your cart is empty" if not st.session_state.cart else "Cart items here")
 
 if __name__ == "__main__":
-    main()
+    main()