Upload 16 files

.env

@@ -0,0 +1,6 @@
+GROQ_API_KEY = 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
+#GROQ_API_KEY=your_groq_api_key_here
+USER_AGENT=MyApp/1.0
+GOOGLE_API_KEY = "AIzaSyAmgPXlA9KIons_kvhZSJKEmAxunTc8cTM"
+TAVILY_API_KEY = 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
+PLACES_API_KEY = AIzaSyBOn9th7l3IskAG-BnDOBpjDmVWB3L7jUg

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -textS3_chromadb.zip filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+*.png
+*.jpg
+# ignore my env files to not reveal the api keys
+*.env 

README.md

@@ -1,12 +1,6 @@
 ---
-title: Restaurantguide
-emoji: 🌍
-colorFrom: green
-colorTo: green
+title: AI_guide
+app_file: main.py
 sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
+sdk_version: 5.3.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

S3_chromadb.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cc56a182384b7d1e79fb83f54273d4290c88e47eab98d3f0ca6ff898c27d623
+size 10180157

chromadblocal.py

@@ -0,0 +1,78 @@
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+import chromadb
+
+class DataHandler:
+    def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2', db_path="D:/Projects/Liminal/AI_Guide/resources/S3_chromadb"):
+        # Initialize the ChromaDB persistent client and embedding model
+        self.client = chromadb.PersistentClient(path=db_path)  # ChromaDB with persistent storage at the specified path
+        self.model = SentenceTransformer(model_name)
+        self.collection = self.client.get_or_create_collection(name="food_places")
+
+    def load_data(self, file_path):
+        """
+        Load data from a CSV file.
+        :param file_path: Path to the CSV file.
+        :return: DataFrame with loaded data.
+        """
+        return pd.read_csv(file_path)
+
+    def get_unique_cities(self):
+        """
+        Retrieve unique cities from the restaurant dataset.
+        :return: List of unique cities.
+        """
+        df = self.load_data("D:/Projects/Liminal/AI_Guide/resources/S3Dataset.csv")
+        return sorted(df['City'].unique().tolist())
+    def process_data(self, df):
+        """
+        Preprocess the DataFrame and generate text embeddings for each row.
+        :param df: DataFrame containing restaurant data.
+        """
+        count = 0
+        for idx, row in df.iterrows():
+
+            combined_text = f"{row['Cuisine']} {row['Location']} {row['Locality']} {row['Cost']}"
+            embedding = self.model.encode(combined_text).tolist()
+
+            # Create new metadata for each row
+            new_metadata = {
+                "restaurant_name": row['Name'],
+                "location": row['Location'],
+                "locality": row['Locality'],
+                "city": row['City'],
+                "votes": row['Votes'],
+                "cost": row['Cost'],
+                "rating": row['Rating'],
+                "uuid": row['Unique_ID'],
+                "image_path": row['Image_Path']
+            }
+
+            # Check if the ID already exists in the collection
+            existing_docs = self.collection.get(ids=[str(idx)])  # Fetch existing document by ID
+
+            if existing_docs['ids']:  # If the ID exists
+                # Check if the metadata is the same
+                existing_metadata = existing_docs['metadatas'][0]  # Get the existing metadata for comparison
+                if existing_metadata == new_metadata:
+                    continue  # Skip if metadata is the same
+
+            # Insert or update the collection
+            self.collection.add(
+                documents=[combined_text],  # Add text for reference
+                metadatas=[new_metadata],   # Use the new_metadata created before the condition
+                embeddings=[embedding],
+                ids=[str(idx)]  # Use index as ID
+            )
+            count = count+1
+            if count%100 == 0:
+                print(f"Inserted/Updated {count} rows into ChromaDB.")
+
+    def get_collection(self):
+        return self.collection  # Return the ChromaDB collection instance
+
+# If you want to run this file separately to update the vector DB
+if __name__ == "__main__":
+    data_handler = DataHandler()
+    df = data_handler.load_data("D:/Projects/Liminal/AI_Guide/resources/S3Dataset.csv")
+    data_handler.process_data(df)

main.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from chromadblocal import DataHandler
+from queryhandler import QueryHandler
+
+# Initialize the DataHandler to access the ChromaDB collection and get unique cities
+data_handler = DataHandler()
+available_cities = data_handler.get_unique_cities()  # Get list of unique cities
+# Initialize the QueryHandler with the ChromaDB collection
+query_handler = QueryHandler(data_handler.get_collection())
+
+# Function to handle user queries
+def process_query(user_prompt):
+    # Query the collection and return top results
+    results = query_handler.query(user_prompt, n_results=5)
+
+    # Generate the response based on the query results
+    recommendation_text, image_paths = query_handler.generate_response(results, user_prompt)
+
+    # Return response text and image paths (not gr.Image components)
+    return recommendation_text, image_paths  # Return text and image paths
+
+# Display greeting message along with available cities
+def display_greeting_and_cities():
+    greeting = ("Hi there! Got questions about restaurants, cuisines, locations, ratings, or costs in these cities?"
+                " Just ask, and I’ll be thrilled to help you find what you need!")
+    cities_list = ", ".join(available_cities)
+    return f"{greeting}\n\nAvailable cities: {cities_list}"
+
+# Create a Gradio interface
+iface = gr.Interface(
+    fn=process_query,  # Function to process input
+    inputs=gr.Textbox(label="Ask about restaurants, cuisines, or more"),  # Custom label for input
+    outputs=[
+        gr.Textbox(label="Recommended Restaurants"),  # Text output for recommendations
+        gr.Gallery(label="Restaurant Images")  # Gallery to display images
+    ],
+    title="Restaurant Query System",
+    description=display_greeting_and_cities()  # Show greeting and cities above the input prompt
+)
+
+# Launch the Gradio app with allowed_paths specified
+if __name__ == "__main__":
+    iface.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=True,
+        allowed_paths=["D:/Projects/Liminal/AI_Guide/resources/uuid_images"]  # Specify allowed paths during launch
+    )

queryhandler.py

@@ -0,0 +1,166 @@
+from sentence_transformers import SentenceTransformer
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+import os
+from dotenv import load_dotenv
+from collections import deque
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class QueryHandler:
+    def __init__(self, collection, llm_model_name='llama-3.3-70b-versatile',
+                 embed_model_name='sentence-transformers/all-MiniLM-L6-v2', max_history=5):
+        self.collection = collection
+        self.embed_model = SentenceTransformer(embed_model_name)
+
+        # Load the Groq API key from environment variable
+        self.groq_api_key = os.getenv('GROQ_API_KEY')
+        if not self.groq_api_key:
+            raise ValueError("GROQ_API_KEY environment variable not set.")
+
+        # Initialize the LLM client with the API key
+        self.llm = ChatGroq(groq_api_key=self.groq_api_key, model_name=llm_model_name)
+
+        # Session history management
+        self.history = deque(maxlen=max_history)  # Store last 'max_history' interactions
+
+    def extract_filters(self, user_prompt):
+        """
+        Use the LLM to extract filter criteria from the user prompt.
+        """
+        extraction_prompt = ChatPromptTemplate.from_template(
+            """
+            Analyze the following query and extract filters for restaurant recommendations:
+            - Cuisine type (if mentioned): Look for specific cuisine preferences.
+            - Location: Identify the city or locality.
+            - Price range: Look for a maximum or minimum price (e.g., $100).
+
+            If any of these details are missing, return them as None.
+            Query: {input}
+            Provide the extracted filters in JSON format like:
+            {{
+                "cuisine_type": "string or None",
+                "location": "string or None",
+                "price": "int or None"
+            }}
+            """
+        )
+        prompt = extraction_prompt.format(input=user_prompt)
+        response = self.llm.invoke(prompt)
+        try:
+            filters = eval(response.content)  # Convert string response to dictionary
+        except Exception as e:
+            filters = {"cuisine_type": None, "location": None, "price": None}
+        return filters
+
+    def query(self, user_prompt, n_results=5):
+        """
+        Process the user query and retrieve filtered results from ChromaDB.
+        """
+        # Generate embedding for the user prompt
+        query_embedding = self.embed_model.encode(user_prompt).tolist()
+
+        # Extract filters using the LLM
+        filters = self.extract_filters(user_prompt)
+
+        # Create the filter dictionary for ChromaDB
+        chromadb_filter = {}
+        if filters.get("cuisine_type"):
+            chromadb_filter["cuisine_type"] = filters["cuisine_type"]
+        if filters.get("location"):
+            chromadb_filter["location"] = filters["location"]
+        if filters.get("price"):
+            chromadb_filter["price"] = {"$lte": filters["price"]}
+
+        # Perform the query in ChromaDB with filters
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=n_results,
+            where=chromadb_filter
+        )
+
+        return results
+
+    def get_recent_context(self):
+        # Retrieve recent history for context, including LLM-generated responses
+        context_parts = []
+        for idx, (prompt, results, llm_response) in enumerate(self.history):
+            metadatas = results.get('metadatas', [])
+            flat_metadatas = [item for sublist in metadatas for item in sublist]
+            context = "\n".join(
+                f"{idx + 1}. Restaurant: {metadata.get('restaurant_name', 'N/A')}, "
+                f"Location: {metadata.get('location', 'N/A')}, "
+                f"Locality: {metadata.get('locality', 'N/A')}, "
+                f"City: {metadata.get('city', 'N/A')}, "
+                f"Votes: {metadata.get('votes', 'N/A')}, "
+                f"Cost: {metadata.get('cost', 'N/A')}, "
+                f"Rating: {metadata.get('rating', 'N/A')}"
+                for metadata in flat_metadatas
+            )
+            # Include the LLM-generated response for each entry
+            context_parts.append(f"Query: {prompt}\nResults:\n{context}\nResponse:\n{llm_response}")
+
+        return "\n".join(context_parts)
+
+    def generate_response(self, results, user_prompt):
+        # Gather recent context from history
+        recent_context = self.get_recent_context()
+
+        # Current query's results
+        metadatas = results.get('metadatas', [])
+        flat_metadatas = [item for sublist in metadatas for item in sublist]
+
+        # Construct recommendation text and collect image paths
+        recommendation_text = ""
+        image_paths = []  # To store image paths for rendering
+        for metadata in flat_metadatas:
+            recommendation_text += (
+                f"Restaurant: {metadata.get('restaurant_name', 'N/A')}, "
+                f"Location: {metadata.get('location', 'N/A')}, "
+                f"Locality: {metadata.get('locality', 'N/A')}, "
+                f"City: {metadata.get('city', 'N/A')}, "
+                f"Votes: {metadata.get('votes', 'N/A')}, "
+                f"Cost: {metadata.get('cost', 'N/A')}, "
+                f"Rating: {metadata.get('rating', 'N/A')}\n"
+            )
+            if metadata.get('image_path'):  # Append valid image paths
+                image_paths.append(metadata['image_path'])
+
+        # LLM prompt template with session context
+        prompt_template = ChatPromptTemplate.from_template(
+            """
+            Previous Conversations:
+            {recent_context}
+
+            Here is the data relevant to your query:
+
+            - **Name**: The restaurant's name.
+            - **Location, Locality, and City**: The address details of the restaurant.
+            - **Cuisine**: Types of cuisines offered by the restaurant.
+            - **Rating**: Average rating on a scale of 5.
+            - **Votes**: Number of people who have rated the restaurant.
+            - **Cost**: Average cost of dining.
+
+            You are a restaurant recommender with knowledge of restaurants, cuisines, ratings, and costs across various cities in India. Respond to queries based on the provided details and recommend the most relevant options based on user preferences. If information is incomplete, provide the best suggestions and encourage follow-up questions.
+
+            Use the recent context only if you require additional information from previous conversations. If the query is not related to the information available to you, make a generic response and let the user know you would be more than happy to help with restaurant recommendations.
+
+            <context>
+            {context}
+            </context>
+            Question: {input}
+            """
+        )
+
+        # Generate the prompt by formatting the template
+        prompt = prompt_template.format(recent_context=recent_context, context=recommendation_text, input=user_prompt)
+
+        # Use the LLM to generate the output
+        response = self.llm.invoke(prompt)  # Pass the prompt string directly
+
+        # Store the prompt, results, and LLM-generated response in the history
+        self.history.append((user_prompt, results, response.content))
+
+        return response.content, image_paths  # Return both recommendation text and image paths

s3bucket_pathadder.py

@@ -0,0 +1,36 @@
+import pandas as pd
+import os
+
+# Load the CSV file
+file_path = "D:/Projects/Liminal/AI_Guide/resources/Dataset.csv"  # Update with your input CSV file path
+df = pd.read_csv(file_path)
+
+# Define S3 bucket details
+bucket_name = "restaurant-resources-liminal"
+region = "ap-south-1"
+s3_base_url = f"https://{bucket_name}.s3.{region}.amazonaws.com/uuid_images/"
+
+# Update the Image_path column with S3 URLs using the Unique_ID column
+df['S3Image_path'] = df['Unique_ID'].apply(lambda x: f"{s3_base_url}{x}.png")
+
+# Save the updated DataFrame back to a new CSV file
+#updated_csv_path = "updated_restaurant_data.csv"
+#df.to_csv(updated_csv_path, index=False)
+
+#print(f"Updated CSV file saved to: {updated_csv_path}")
+"""
+# Function to extract the file type and build S3 URL
+def generate_s3_url(image_path, unique_id):
+    # Extract file extension dynamically
+    file_extension = os.path.splitext(image_path)[-1]  # E.g., '.jpg', '.png'
+    # Build the full S3 URL
+    return f"{s3_base_url}{unique_id}{file_extension}"""
+
+# Apply the function to create a new 'S3_Image_URL' column
+#df['S3_Image_URL'] = df.apply(lambda row: generate_s3_url(row['Image_path'], row['Unique_ID']), axis=1)
+
+# Save the updated DataFrame to a new CSV
+output_file_path = 'D:/Projects/Liminal/AI_Guide/resources/S3Dataset.csv'
+df.to_csv(output_file_path, index=False)
+
+print(f"Updated CSV file saved at: {output_file_path}")

webbaseloader.py

@@ -0,0 +1,159 @@
+import requests
+import pandas as pd
+import os
+from dotenv import load_dotenv
+import time
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Your Google API Key
+API_KEY = os.getenv('PLACES_API_KEY')
+
+# File paths
+input_csv = "D:/Projects/Liminal/AI_Guide/resources/restaurants_1.csv"  # Input CSV file
+output_dir = 'D:/Projects/Liminal/AI_Guide/resources/restaurant_images'  # Directory to save images
+PHOTO_BASE_URL = "https://maps.googleapis.com/maps/api/place/photo"
+output_csv = "D:/Projects/Liminal/AI_Guide/resources/output.csv"
+# Create output directory if it doesn't exist
+os.makedirs(output_dir, exist_ok=True)
+
+
+def get_place_id(query, api_key):
+    """
+    Search for a place using Google Places API and return the place_id.
+    """
+    url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
+    params = {
+        'query': query,
+        'key': api_key
+    }
+    response = requests.get(url, params=params)
+    data = response.json()
+
+    if data['status'] == 'OK' and len(data['results']) > 0:
+        return data['results'][0]['place_id']
+    else:
+        print(f"Place not found for query: {query}")
+        return None
+
+
+def get_photo_reference(place_id, api_key):
+    """
+    Get the photo reference for a place using its place_id.
+    """
+    url = "https://maps.googleapis.com/maps/api/place/details/json"
+    params = {
+        'place_id': place_id,
+        'key': api_key
+    }
+    response = requests.get(url, params=params)
+    data = response.json()
+
+    if data['status'] == 'OK' and 'photos' in data['result']:
+        return data['result']['photos'][0]['photo_reference']
+    else:
+        print(f"No photos found for place_id: {place_id}")
+        return None
+
+
+def download_photo(photo_reference, api_key, output_path, retries=3, delay=30):
+    """
+    Download and save a photo using the photo reference with retry logic.
+    """
+    url = f"https://maps.googleapis.com/maps/api/place/photo"
+    params = {
+        'photoreference': photo_reference,
+        'key': api_key,
+        'maxwidth': 400,  # Specify the image resolution
+        'maxheight': 400
+    }
+
+    for attempt in range(1, retries + 1):
+        try:
+            response = requests.get(url, params=params, stream=True, timeout=10)
+            if response.status_code == 200:
+                with open(output_path, 'wb') as file:
+                    for chunk in response.iter_content(1024):
+                        file.write(chunk)
+                print(f"Image saved to {output_path}")
+                return True
+            else:
+                print(f"Failed to download image: {response.status_code} - {response.text}")
+        except requests.exceptions.RequestException as e:
+            print(f"Error downloading photo (Attempt {attempt}/{retries}): {e}")
+
+        # Wait before retrying
+        if attempt < retries:
+            print(f"Retrying in {delay} seconds...")
+            time.sleep(delay)
+
+    print(f"Failed to download image after {retries} attempts.")
+    return False
+
+
+def main():
+    """
+    Main script to process the input CSV, fetch place IDs, photo references, and download images.
+    """
+    # Load the CSV file
+    df = pd.read_csv(input_csv)
+
+    # Ensure the CSV contains the required columns
+    required_columns = ['Name', 'Location', 'Locality', 'City']
+    for col in required_columns:
+        if col not in df.columns:
+            print(f"CSV file must contain the following columns: {', '.join(required_columns)}")
+            return
+
+    # Add a new column for image paths
+    if 'Image_Path' not in df.columns:
+        df['Image_Path'] = None
+
+    # Get a list of existing image names in the output directory
+    existing_images = {os.path.splitext(f)[0] for f in os.listdir(output_dir) if
+                       os.path.isfile(os.path.join(output_dir, f))}
+
+    # Iterate through each row in the CSV
+    for index, row in df.iterrows():
+        # Construct a sanitized image name
+        name = row['Name']
+        safe_name = "".join(c if c.isalnum() else "_" for c in name)
+
+        # Skip if the image already exists in the directory
+        if safe_name in existing_images:
+            print(f"Image already exists for {row['Name']}, skipping...")
+            continue
+
+        # Construct a detailed search query
+        location = row['Location']
+        locality = row['Locality']
+        city = row['City']
+        query = f"{name}, {location}, {locality}, {city}"
+
+        print(f"Processing: {query}")
+
+        # Step 1: Get place_id
+        place_id = get_place_id(query, API_KEY)
+        if not place_id:
+            continue
+
+        # Step 2: Get photo_reference
+        photo_reference = get_photo_reference(place_id, API_KEY)
+        if not photo_reference:
+            continue
+
+        # Step 3: Download the photo
+        output_path = os.path.join(output_dir, f"{safe_name}.jpg")
+
+        if download_photo(photo_reference, API_KEY, output_path):
+            # Update the DataFrame with the image path
+            df.at[index, 'Image_Path'] = output_path
+
+    # Save the updated DataFrame to a new CSV
+    df.to_csv(output_csv, index=False)
+    print(f"Updated CSV saved to {output_csv}")
+
+
+if __name__ == "__main__":
+    main()