Update app.py

app.py

@@ -6,10 +6,9 @@ import google.generativeai as genai
 from PIL import Image
 import PyPDF2
 import os
-import json
 from langchain.agents import initialize_agent, Tool
 from langchain.agents.agent_types import AgentType
-from PIL import Image
+from difflib import get_close_matches
 from dotenv import load_dotenv
 
 # Load environment variables
@@ -25,22 +24,49 @@ def configure_gemini(api_key):
 model = configure_gemini(os.environ['GOOGLE_API_KEY'])
             
 # Initialize Gemini models
-llm_flash_exp = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")
+llm_flash_exp = ChatGoogleGenerativeAI(
+    model="gemini-2.0-flash-exp",
+    max_retries=2  # Limit retries to 2
+)
 
 class SmartShoppingAssistant:
     def __init__(self, products_df):
         self.df = products_df
         self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
         self.setup_agent()
+    
+    def find_closest_product(self, product_name, threshold=0.6):
+        """Find the closest matching product name using fuzzy matching"""
+        matches = get_close_matches(
+            product_name.upper(),
+            self.df['ProductName'].str.upper().tolist(),
+            n=1,
+            cutoff=threshold
+        )
+        return matches[0] if matches else None
+    
+    def search_products_fuzzy(self, product_names):
+        """Search for products using fuzzy matching"""
+        results = pd.DataFrame()
+        for name in product_names:
+            closest_match = self.find_closest_product(name)
+            if closest_match:
+                matched_products = self.df[self.df['ProductName'].str.upper() == closest_match.upper()]
+                results = pd.concat([results, matched_products])
+        return results
         
     def setup_agent(self):
         """Set up the LangChain agent with necessary tools"""
         def search_products(query):
             try:
+                # Extract product names from the query
+                product_names = [name.strip('"\'') for name in query.split(' or ')]
+                product_names = [name.split('==')[1].strip() if '==' in name else name for name in product_names]
+                
                 if 'RetailPrice' in self.df.columns:
                     self.df['RetailPrice'] = pd.to_numeric(self.df['RetailPrice'].str.replace('$', ''), errors='coerce')
                 
-                results = self.df.query(query)
+                results = self.search_products_fuzzy(product_names)
                 return results.to_string() if not results.empty else "No products found matching your criteria."
             except Exception as e:
                 return f"Error executing query: {str(e)}"
@@ -49,7 +75,7 @@ class SmartShoppingAssistant:
             Tool(
                 name="Product Search",
                 func=search_products,
-                description="Search for products in the supermarket database"
+                description="Search for products in the supermarket database using fuzzy matching"
             )
         ]
         
@@ -58,27 +84,33 @@ class SmartShoppingAssistant:
             memory=self.memory,
             llm=llm_flash_exp,
             agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
-            verbose=True
+            verbose=True,
+            max_iterations=3  # Limit the number of iterations
         )
     
     def process_natural_language_query(self, query):
         """Process natural language query and return relevant products"""
+
+        product_list = self.df['ProductName'].tolist()
+        product_string = ", ".join(product_list)
         try:
             prompt = f"""
-            Convert this shopping request into a pandas query string for a DataFrame with columns: 
-            {', '.join(self.df.columns)}
+            Convert this shopping request into a list of product names to search for. The response should be in the format:
+            ProductName == "PRODUCT1" or ProductName == "PRODUCT2" or ProductName == "PRODUCT3"
             
             Shopping request: {query}
 
-            List of available products: {str(self.df['ProductName'].tolist())}
-            
-            Return only the pandas query string, nothing else.
+            Available products will be matched approximately or use you intelligent to look at product and list and see the ones that match
+            , so focus on the main product names.
+            Return only the search string, nothing else.
+
+            This is the list of products: {product_string}
             """
             
             response = llm_flash_exp.predict(prompt)
             structured_query = response.strip()
             
-            result = self.agent.run(f"Execute this query and return matching products: {structured_query}")
+            result = self.agent.run(f"Search for products matching the specified names: {structured_query}")
             return result
         except Exception as e:
             return f"Error processing query: {str(e)}"
@@ -103,6 +135,7 @@ class SmartShoppingAssistant:
         except Exception as e:
             return f"Error processing PDF: {str(e)}"
 
+# Main function remains the same
 def main():
     st.set_page_config(page_title="Smart Shopping Assistant", layout="wide")
     st.title("🛒 Smart Shopping Assistant")