Upload 12 files

.env

@@ -0,0 +1 @@
+GROQ_API_KEY="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"

.gitattributes

@@ -1,35 +1,2 @@
-*.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
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -1,20 +1,499 @@
----
-title: Reservation Chatbot
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: LLM based restaurant reservation bot
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+
+
+#  Restaurant Reservation Assistant – LLM + Streamlit App
+
+## 🚀 Overview
+
+This is a conversational restaurant reservation assistant built using **LLMs (llama3-8b-8192)**, **Streamlit**, and **SQLite**. The assistant interacts with users in natural language to help them book tables, answer restaurant queries, and manage reservation workflows.
+
+---
+
+## ⚙️ Setup Instructions
+
+### 🛠️ Requirements
+
+* `Python 3.8+`
+* `chromadb==1.0.10`
+* `openai==1.82.0`
+* `pandas==2.2.3`
+* `redis==6.1.0`
+* `sentence-transformers==4.1.0`
+* `streamlit==1.45.1`
+* `transformers==4.52.3`
+
+
+
+
+---
+
+### 🧩 Installation
+
+```bash
+git clone https://github.com/Sri-Vallabh/LLM-based-restaurant-reservation-chatbot.git
+cd restaurant-reservation-assistant
+pip install -r requirements.txt
+```
+
+### 🔑 API Key Setup
+
+To use the LLM features, you'll need an API key from [Groq Console](https://console.groq.com/keys).
+Create an account (if you haven’t already), generate your key, and set it as an environment variable:
+
+```bash
+export GROQ_API_KEY=your_api_key_here
+```
+
+Or, add it to a `.env` file and load it using your preferred method.
+
+### 🔗 Running the App
+
+```bash
+streamlit run app.py
+```
+
+Ensure the `restaurant_reservation.db` is in the `/db` folder inside the root directory. This contains all restaurant, table, slot, and reservation data.
+
+
+
+---
+
+## 🧠 Language Model & Retrieval Architecture
+
+This project leverages **Meta’s LLaMA 3 8B** language model (`llama3-8b-8192`), accessed via **Groq’s OpenAI-compatible API**. Groq’s unique **LPU (Language Processing Unit)** hardware delivers ultra-fast inference speeds—up to 876 tokens per second for LLaMA 3 8B—enabling near-instantaneous responses even for complex, multi-step conversations. The model’s 8192-token context window allows it to efficiently process extended dialogues, rich database results, and prompt histories.
+
+The system is built around a **Retrieval-Augmented Generation (RAG)** architecture. Here’s how it works:
+
+- **Semantic Search & Retrieval:**  
+  - **ChromaDB** is used as the vector database to store embeddings of restaurant, table, and slot data.
+  - User queries and database content are converted to embeddings using the **all-MiniLM-L6-v2** sentence transformer model from Hugging Face’s Sentence Transformers library.
+  - This enables the system to quickly find semantically similar information, such as restaurants matching a cuisine or tables with specific features.
+- **Grounding in Real-Time Data:**  
+  - The LLM is provided with both the results of semantic search and, when needed, structured data retrieved from the SQLite database.
+  - This ensures responses are always up-to-date and contextually accurate.
+- **Modular, Multi-Step Processing:**  
+  - The LLM is used in a modular fashion, with specialized prompts for each stage of the conversation:
+
+### **Key Processing Steps**
+
+1. **Intent Detection**  
+   Determines the user’s goal—booking a table, checking availability, asking general questions, or handling edge cases and non-sequiturs.
+
+2. **Information Extraction**  
+   Extracts structured fields (restaurant name, user name, contact info, party size, reservation time) from free-form user input.
+
+3. **Extracting information from database**  
+   - **Semantic Search:** For natural language queries (e.g., “Italian restaurants with outdoor seating”), the LLM triggers a semantic search in ChromaDB, powered by `all-MiniLM-L6-v2` embeddings.
+   ### Cases where semantic search approach fails:
+   - **SQL Query Generation:** For precise data requests (e.g., “Show all tables available at 7pm”), the LLM generates SQL queries to fetch data from the SQLite database.
+
+4. **Result Interpretation**  
+   Converts raw SQL or semantic search results into clear, conversational summaries for the user.
+
+5. **Multi-Turn Dialogue Management**  
+   Maintains context across messages, using previous inputs and system memory to build coherent, helpful conversations with the user.
+
+### **Security & Control**
+
+- **No Direct Booking by LLM:**  
+  For security, the LLM is not permitted to perform direct database modifications. Final reservations are handled by a dedicated, safeguarded logic module.
+- **Prompt Engineering:**  
+  Each task (intent, extraction, query, summarization) is managed by a specialized prompt, improving reliability and modularity.
+
+---
+
+## **In summary:**  
+This architecture combines the speed and intelligence of LLaMA 3 via Groq with robust retrieval from ChromaDB (using `all-MiniLM-L6-v2` embeddings) and SQLite, ensuring fast, accurate, and context-aware responses for every user query.
+
+
+## 💬 Example User Journeys with Application Walkthrough
+
+
+Below are screenshots showing the end-to-end flow of the restaurant reservation assistant in action:
+
+---
+
+### 🟢 Image 1: Landing Page  
+![Opening](assets/landing.png)
+
+The landing page welcomes users and prompts:  
+**"Ask something about restaurants or reservations..."** 
+
+
+This initiates a free-form, conversational interface for users to interact naturally.
+Here, also names of restaurants, cuisines, special features can be seen, which also stays along with the conversation thread which is scrollable.
+
+---
+
+### 💬 Image 2: General Conversation  
+![Step 1](assets/greet_general_convo.png)
+
+The assistant engages in friendly conversation, understanding user intent like greetings, small talk, or queries about restaurants.
+
+---
+
+### 🔍 Image 3: Database Query + Interpretation  
+![Step 2](assets/general_conv_info_through_chat.png)
+
+The assistant first uses ChromaDB with semantic search to quickly retrieve relevant answers from a knowledge base. If no confident result is found, it dynamically generates an appropriate SQL SELECT query, executes it on the structured database, interprets the result, and returns a natural, conversational response.
+
+---
+
+### 🤝 Image 4 to 6: Information Gathering + Suggestions  
+![Step 3](assets/name_entering.png)  
+![Step 4](assets/all_resto.png) 
+### Handling random text
+![Step 5](assets/rubbish.PNG) 
+
+Through ongoing conversation, the assistant extracts necessary reservation information:  
+- 🏨 Restaurant name  
+- 🙋 User name  
+- 📱 Contact  
+- 👥 Party size  
+- ⏰ Time
+
+It continues to help the user by checking availability and making suggestions.
+
+---
+
+### ✅ Image 7: Ready for Booking Confirmation  
+![Step 6](assets/ready_to_book.png)
+
+Once all required information is gathered, the assistant summarizes the reservation details and asks for user confirmation with a simple **`book`** command.
+
+---
+
+### 🧾 Image 8: Booking Confirmation  
+![Step 7](assets/booking_successful.png)
+
+Booking is processed successfully!
+
+- Restaurant: **Pasta Republic**  
+- Time: **20 on 2025-05-12**  
+- Party size: **15**  
+- Tables booked: **4** (4 tables are needed to accomodate 15 people as one table has 4 seating capacity)  
+- Reservation ID: **#10** 
+The system calculates the number of tables needed using `ceil(party_size / 4)`, verifies table availability, reserves the required slots, and finalizes the booking.
+
+The assistant informs the user:
+
+
+👉 Please mention this Reservation ID at the restaurant reception when you arrive.
+
+This flow demonstrates a complete, intelligent reservation assistant that uses natural language processing, database querying, and interactive UX logic to help users make hassle-free bookings.
+
+
+---
+## Some other results:
+
+
+![Some results](assets/some_results.png)
+---
+### If user enters random text:
+![Some results](assets/rubbish.png)
+
+
+
+
+# Database explanation
+* **`restaurant_reservation.db`**:
+
+  * This SQLite database contains the following tables:
+
+    * **`restaurants`**:
+
+      * Stores information about each restaurant, such as its **name**, **cuisine**, **location**, **seating capacity**, **rating**, **address**, **contact details**, **price range**, and **special features**.
+      * The **`id`** field serves as a unique identifier for each restaurant.
+      * **Important Note**: The **`id`** is used internally in the database and should not be exposed to the user.
+
+    * **`tables`**:
+
+      * Stores information about tables at each restaurant.
+      * Each table is associated with a **`restaurant_id`**, linking it to a specific restaurant.
+      * Each table has a **capacity** (default is 4), which indicates how many guests it can accommodate.
+      * The **`id`** field uniquely identifies each table and should not be shared with the user.
+
+    * **`slots`**:
+
+      * Stores information about the availability of each table.
+      * Each slot corresponds to a **1-hour** time block for a specific table on a particular day (e.g., a table might have slots available from **9AM to 9PM**).
+      * **`is_reserved`** indicates whether the slot is booked (**1**) or available (**0**).
+      * **`date`** is hardcoded to **2025-05-12**, and the **`hour`** field defines the start time for the reservation (ranging from **9** to **20**, representing 9AM to 8PM).
+      * The **`slot.id`** and **`table_id`** are used to uniquely identify the slots and link them to the relevant tables.
+
+    * **`reservations`**:
+
+      * Stores reservation details made by the user, including:
+
+        * **`restaurant_id`**: Links the reservation to a specific restaurant.
+        * **`user_name`**: The name of the user who made the reservation.
+        * **`contact`**: The contact details (e.g., phone number) of the user.
+        * **`date`**: Hardcoded to **2025-05-12**, representing the reservation date.
+        * **`time`**: The starting hour of the reservation, which matches a slot's **hour** field.
+        * **`party_size`**: The number of people for whom the reservation is made.
+      * The **`id`** is used to uniquely identify each reservation, but it is not exposed to the user.
+
+    * **`reservation_tables`**:
+
+      * A junction table that links reservations to tables.
+      * Contains:
+
+        * **`reservation_id`**: Links the reservation to the **`reservations`** table.
+        * **`table_id`**: Links the reservation to the relevant **`tables`**.
+      * This table helps associate a reservation with the actual tables that are booked for that reservation.
+
+
+## 📄 Prompt Engineering Strategy
+
+### ✨ Design Principles
+
+1. **🔁 Separation of Concerns**
+   For different purposes, I have engineered different prompts that are modular, making the assistant easier to debug, maintain, and enhance:
+
+   * **Intent classification** (`determine_intent.txt`)
+   * **Information extraction** (`store_user_info.txt`)
+   * **SQL query generation** (`schema_prompt.txt`)
+   * **SQL result interpretation** (`interpret_sql_result.txt`)
+   * **Natural reply generation** (`generate_reservation_conversation.txt`)
+
+2. **🧠 Context-Aware Memory Management**
+
+   * Maintains `chat_history`, `user_data`, and `last_reply` using Streamlit session state.
+   * Tracks conversation context across turns to avoid repetition, keep interactions natural, and gracefully handle incomplete data.
+
+3. **✅ Controlled Confirmation Flow**
+
+   * Prompts ensure that **only when all required fields (restaurant name, name, contact, party size, and time)** are filled, the assistant proceeds to ask for booking confirmation.
+   * Prevents accidental bookings and ensures user consent before writing to the database.
+
+4. **🛡️ Safe Query Execution**
+
+   * Only **SELECT statements** generated by the LLM are allowed to be executed directly.
+   * INSERT/UPDATE operations (like booking a reservation) are handled by a **separate, controlled module**, protecting the database from unintended writes or corruption.
+
+5. **📦 Iterative Prompt Optimization**
+
+   * Prompts have been fine-tuned through iterative experimentation and real conversation testing.
+   * Incorporated **few-shot examples** where relevant to guide the LLM.
+   * Prompts are designed to gracefully handle edge cases, e.g., when users give partial or ambiguous information.
+
+6. **📏 Robust Format Enforcement & Cleaning**
+
+   * JSON outputs (e.g., for `store_user_info`) include explicit instructions on quoting keys/values to prevent parsing issues.
+   * Pre/post-processing logic strips any unexpected or extra text surrounding JSON responses from the LLM.
+   * Regular expressions and cleaning checks are used to sanitize LLM responses before using them in downstream logic.
+
+7. **🌐 User-Centric Design**
+
+   * Prompts use natural, polite tone and context-aware replies, improving user trust and UX.
+   * Conversational flow shifts fluidly between transactional (booking) and informational (restaurant FAQs) based on detected intent, also handling **multiple-intent** cases.
+
+---
+
+
+### ⚠️ Error Handling & Edge Cases
+
+This assistant is designed to offer a smooth and reliable user experience, even in unexpected scenarios. The following mechanisms are implemented to handle errors and edge cases effectively:
+
+#### ✅ Error Handling
+
+* **LLM Output Sanitization**:
+  When the LLM occasionally adds extra text before or after the expected response (e.g., in SQL queries), the output is parsed and cleaned using regex or string manipulation to extract only the required format. This ensures that unexpected formatting does not break the application.
+
+* **Safe Execution with Try-Catch Blocks**:
+  All critical operations — especially SQL queries and bookings — are wrapped in `try-except` blocks. This prevents the UI from crashing and allows the assistant to gracefully inform the user about what went wrong.
+
+* **Pre-Booking Availability Recheck**:
+  Just before finalizing a reservation, the system re-checks for table and slot availability. This is to prevent race conditions where multiple users might try to book the same slot at the same time — ensuring consistency and avoiding double bookings.
+
+ * **Preventive measures for malicious data injection/Database modification by prompt**:
+The LLM does not directly execute SQL INSERT statements. Instead, it only interprets user intent, and can perform certain select queries to gather information. There is a dedicated backend module securely handles data injection for reservations , reducing the risk of malicious injection or malformed queries.
+
+---
+
+#### 🔍 Edge Cases
+
+* **Random or Nonsensical User Input**:
+  If a user inputs irrelevant or nonsensical text (e.g., "asdf123", emojis, or spam), the assistant classifies it as an invalid intent (tagged as `RUBBISH`) and politely asks the user to rephrase or clarify their request.
+
+* **Partial Reservation Information**:
+  When users provide only some details (e.g., name but not time), the assistant remembers the known information and continues the conversation by asking only for the missing fields, without repeating previously collected data.
+
+* **Privacy Protection**:
+Users cannot ask about bookings made by others. The SQL data access layer enforces this by exposing only the current user’s booking context. There is no direct query access to personal or third-party reservation data.
+
+* **Restaurant Not Found**:
+  If the user provides a restaurant name that does not exist in the database, the assistant notifies them and may offer to show a list of available restaurants.
+
+* **Unavailable Timeslots**:
+  If the requested time has no available tables (due to existing reservations), the assistant explains this clearly and suggests choosing a different time.
+
+---
+
+By handling these cases gracefully, the assistant ensures that users have a seamless experience even when unexpected situations arise.
+
+
+
+
+
+
+
+
+## 🧭 Assumptions, Limitations & Enhancements
+
+### Assumptions:
+* There is a hardcoded 4-person table capacity, so the system itself selects multiple tables that are available at that time.
+* Reservation slots are fixed to **2025-05-12**, and all reservations are for this date.
+---
+### ⚠️ Limitations:
+
+* The system currently supports reservations only for a fixed date (2025-05-12). This could be extended to multi-day support by adding appropriate entries to the database.
+* Since the system relies on Large Language Models (LLMs), there's **no absolute guarantee of perfect behavior**—LLMs can occasionally misinterpret queries, miss context, or produce inaccurate outputs.
+* **Table preferences cannot be specified** by the user. The system auto-assigns tables based on availability, so users cannot choose specific table locations (e.g., window-side, outdoor, etc.).
+* Only **select queries** are executed directly by the LLM to ensure **data safety**. For insert/update operations (e.g., booking), a separate transaction module is used.
+
+
+---
+### Future Enhancements:
+
+* Expand the system to allow for multi-day reservations.
+* Also add table preferences to choose(eg. beside window,private space).
+* Add features like user authentication, personalized recommendations, and more sophisticated handling of party sizes and table combinations.
+
+### 🔮 Future Enhancements in deployment
+
+* ✅ Date picker and calendar integration
+* 📲 SMS/WhatsApp confirmation with reservation ID
+* 🧾 Admin dashboard to manage reservations & analytics
+* 🌐 Multilingual support for non-English customers
+* 🔌 API-first backend to support mobile and kiosk interfaces
+
+---
+
+
+
+## 📎 File Structure
+
+```
+├── app.py
+├── tools.py
+├── var.py
+├── requirements.txt
+├── Business Strategy Presentation/
+│   ├── app.js
+│   ├── index.html
+│   ├── style.js
+├── prompts/
+│   ├── determine_intent.txt
+│   ├── generate_reservation_conversation.txt
+│   ├── interpret_sql_result.txt
+│   ├── schema_prompt.txt
+│   └── store_user_info.txt
+├── db/
+│   └── restaurant_reservation.db
+└── README.md
+```
+
+### Explanation of Each File
+
+#### 1. **`app.py`**
+
+* The main application file that drives the restaurant reservation system.
+* Handles user input, coordinates prompt usage, calls functional tools, executes SQL queries, and returns conversational responses.
+* Acts as the central orchestrator between all components.
+
+#### 2. **`tools.py`**
+
+* Contains core utility functions used throughout the system.
+* Includes logic for:
+
+  * Determining user intent
+  * Storing and updating user information
+  * Generating reservation-related conversations
+  * Creating and interpreting SQL queries
+* Serves as the modular backend logic layer for reusable operations.
+
+#### 3. **`var.py`**
+
+* Defines classes and configuration variables.
+* Includes:
+
+  * `SchemaVectorDB`: for handling schema-related semantic search
+  * `FullVectorDB`: for broader retrieval tasks using vector similarity
+* Facilitates integration of ChromaDB and semantic retrieval workflows.
+
+#### 4. **`prompts/` Folder**
+
+Stores prompt templates that guide the behavior of the language model (LLM):
+
+* **`determine_intent.txt`**:
+  Prompt for classifying user messages into intents like `greet`, `select`, `book`, or irrelevant.
+
+* **`generate_reservation_conversation.txt`**:
+  Handles multi-turn interactions to collect user details and guide reservations.
+
+* **`interpret_sql_result.txt`**:
+  Formats raw SQL query results into natural-sounding responses.
+
+* **`schema_prompt.txt`**:
+  Describes the SQLite database schema and provides rules for query generation.
+
+* **`store_user_info.txt`**:
+  Extracts and stores user details like name, contact info, party size, and reservation time.
+
+#### 5. **`db/` Folder**
+
+* Contains the SQLite database (`restaurant_reservation.db`) with all restaurant, table, and reservation information.
+* Used to run SQL queries for booking and retrieving restaurant details.
+
+---
+
+
+
+## 📊 Vertical Expansion
+
+This solution can be adapted for:
+
+* ✈️ Airlines (seat booking assistants)
+* 🏥 Clinics & Hospitals (appointment schedulers)
+* 🎟️ Event Ticketing Systems (concerts, sports, etc.)
+* 🏨 Hotels (room booking, amenities)
+
+---
+
+## 🥇 Competitive Advantages
+
+1. 🔁 Multi-turn conversation memory (session-state-based and intent based)
+2. 🧠 Contextual intent handling with seamless switching between FAQ and transactional flows
+3. 📦 Modular LLM prompt architecture for future scaling
+4. 🔒 Secure and Controlled SQL Access
+Only read-only SQL (SELECT) statements are generated and executed via the LLM to prevent any risk of data corruption.
+Reservation actions like INSERT or UPDATE are handled securely in a separate logic module, ensuring strict control over data modification.
+
+---
+
+## 📅 Implementation Timeline
+
+| Phase   | Description                            | Duration |
+| ------- | -------------------------------------- | -------- |
+| Phase 1 | Database creation+LLM sql query creation and interpretation              | 1st day   |
+| Phase 2 | Intent detection+conversational flow | 1st day  |
+| Phase 3 | Booking and edge-case handling    | 2nd day    |
+| Phase 4 | Presentation & packaging               | 2nd day    |
+
+---
+
+## 👥 Key Stakeholders
+
+* Restaurant Manager / Owner
+* Frontdesk / Host
+* Customer Service Ops
+* Technical Dev Team
+
+---
+
+
+
+
+
+
+

app.py

@@ -0,0 +1,500 @@
+import streamlit as st
+from openai import OpenAI
+import sqlite3
+import pandas as pd
+import re
+import json
+from sticky import sticky_container
+import chromadb
+from sentence_transformers import SentenceTransformer
+from transformers import pipeline
+import hashlib
+import inspect
+from tools import *
+from var import SCHEMA_DESCRIPTIONS, SchemaVectorDB, FullVectorDB
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+# Set your Groq API key
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+
+# Initialize Groq's OpenAI-compatible client
+client = OpenAI(
+    api_key=GROQ_API_KEY,
+    base_url="https://api.groq.com/openai/v1"
+)
+
+# --- Load prompt templates from prompts folder ---
+with open("prompts/determine_intent.txt", "r", encoding="utf-8") as f:
+    determine_intent_prompt = f.read()
+
+with open("prompts/generate_reservation_conversation.txt", "r", encoding="utf-8") as f:
+    generate_reservation_conversation_prompt = f.read()
+
+with open("prompts/interpret_sql_result.txt", "r", encoding="utf-8") as f:
+    interpret_sql_result_prompt = f.read()
+
+with open("prompts/schema_prompt.txt", "r", encoding="utf-8") as f:
+    schema_prompt = f.read()
+
+with open("prompts/store_user_info.txt", "r", encoding="utf-8") as f:
+    store_user_info_prompt = f.read()
+
+
+
+st.set_page_config(page_title="FoodieSpot Assistant", layout="wide")
+
+
+# --- Initialize State ---
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+
+if 'user_data' not in st.session_state:
+    st.session_state.user_data = {
+        "restaurant_name": None,
+        "user_name": None,
+        "contact": None,
+        "party_size": None,
+        "time": None
+    }
+if 'vector_db' not in st.session_state:
+    st.session_state.vector_db = SchemaVectorDB()
+vector_db = st.session_state.vector_db
+if 'full_vector_db' not in st.session_state:
+    st.session_state.full_vector_db = FullVectorDB()
+# Track last assistant reply for context
+if 'last_assistant_reply' not in st.session_state:
+    st.session_state.last_assistant_reply = ""
+# Fixed container at top for title + reservation
+reservation_box = sticky_container(mode="top", border=False,z=999)
+
+with reservation_box:
+    st.text("")
+    st.text("")
+    st.title("🍽️ FoodieSpot Assistant")
+    cols = st.columns([3, 3, 3, 2, 2, 1])
+
+    with cols[0]:
+        restaurant_name = st.text_input(
+            "Restaurant Name",
+            value=st.session_state.user_data.get("restaurant_name") or "",
+            key="restaurant_name_input"
+        )
+        if restaurant_name!="":
+            st.session_state.user_data["restaurant_name"] = restaurant_name
+
+    with cols[1]:
+        user_name = st.text_input(
+            "Your Name",
+            value=st.session_state.user_data.get("user_name") or "",
+            key="user_name_input"
+        )
+        if user_name!="":
+            st.session_state.user_data["user_name"] = user_name
+
+    with cols[2]:
+        contact = st.text_input(
+            "Contact",
+            value=st.session_state.user_data.get("contact") or "",
+            key="contact_input"
+        )
+        if contact!="":
+            st.session_state.user_data["contact"] = contact
+
+    with cols[3]:
+        party_size = st.number_input(
+            "Party Size",
+            value=st.session_state.user_data.get("party_size") or 0,
+            key="party_size_input"
+        )
+        if party_size!=0:
+            st.session_state.user_data["party_size"] = party_size
+
+    with cols[4]:
+        time = st.number_input(
+            "Time(24hr form, 9-20, 8 ~ null)",
+            min_value=8,
+            max_value=20,
+            value=st.session_state.user_data.get("time") or 8,
+            key="time_input"
+        )
+        if time!=8:
+            st.session_state.user_data["time"] = time
+        # Place the BOOK button in the last column
+    with cols[5]:
+        st.text("")
+        st.text("")
+        book_clicked = st.button("BOOK", type="primary")
+        # Add a green BOOK button (primary style)
+    # book_clicked = st.button("BOOK", type="primary")
+
+    if book_clicked:
+        # Check if all required fields are filled
+        required_keys = ["restaurant_name", "user_name", "contact", "party_size", "time"]
+        if all(st.session_state.user_data.get(k) not in [None, "", 0, 8] for k in required_keys):
+            booking_conn = None
+            try:
+                user_data = st.session_state.user_data
+                party_size = int(user_data["party_size"])
+                tables_needed = -(-party_size // 4)
+
+                booking_conn = sqlite3.connect("db/restaurant_reservation.db")
+                booking_cursor = booking_conn.cursor()
+
+                booking_cursor.execute("SELECT id FROM restaurants WHERE LOWER(name) = LOWER(?)", (user_data["restaurant_name"],))
+                restaurant_row = booking_cursor.fetchone()
+                if not restaurant_row:
+                    raise Exception("Restaurant not found.")
+                restaurant_id = restaurant_row[0]
+
+                booking_cursor.execute("""
+                    SELECT t.id AS table_id, s.id AS slot_id
+                    FROM tables t
+                    JOIN slots s ON t.id = s.table_id
+                    WHERE t.restaurant_id = ?
+                    AND s.hour = ?
+                    AND s.date = '2025-05-12'
+                    AND s.is_reserved = 0
+                    LIMIT ?
+                """, (restaurant_id, user_data["time"], tables_needed))
+                available = booking_cursor.fetchall()
+
+                if len(available) < tables_needed:
+                    raise Exception("Not enough available tables.")
+
+                booking_cursor.execute("""
+                    INSERT INTO reservations (restaurant_id, user_name, contact, date, time, party_size)
+                    VALUES (?, ?, ?, '2025-05-12', ?, ?)
+                """, (restaurant_id, user_data["user_name"], user_data["contact"], user_data["time"], party_size))
+                reservation_id = booking_cursor.lastrowid
+
+                for table_id, _ in available:
+                    booking_cursor.execute("INSERT INTO reservation_tables (reservation_id, table_id) VALUES (?, ?)", (reservation_id, table_id))
+
+                slot_ids = [slot_id for _, slot_id in available]
+                booking_cursor.executemany("UPDATE slots SET is_reserved = 1 WHERE id = ?", [(sid,) for sid in slot_ids])
+
+                booking_conn.commit()
+
+                booking_cursor.execute("SELECT name FROM restaurants WHERE id = ?", (restaurant_id,))
+                restaurant_name = booking_cursor.fetchone()[0]
+
+                confirmation_msg = (
+                    f"✅ Booking processed successfully!\n\n"
+                    f"📍 Restaurant: **{restaurant_name}**\n"
+                    f"⏰ Time: **{user_data['time']} on 2025-05-12**\n"
+                    f"🍽️ Tables Booked: **{tables_needed}**\n"
+                    f"🆔 Reservation ID: **{reservation_id}**\n\n"
+                    f"👉 Please mention this Reservation ID at the restaurant reception when you arrive."
+                )
+
+                st.success(confirmation_msg)
+                st.session_state.chat_history.append({'role': 'assistant', 'message': confirmation_msg})
+                st.session_state.user_data["restaurant_name"] = None
+                st.session_state.user_data["party_size"] = None
+                st.session_state.user_data["time"] = None
+                st.session_state.last_assistant_reply = ""
+            except Exception as e:
+                if booking_conn:
+                    booking_conn.rollback()
+                st.error(f"❌ Booking failed: {e}")
+            finally:
+                if booking_conn:
+                    booking_cursor = None
+                    booking_conn.close()
+        else:
+            st.warning("⚠️ Missing user information. Please provide all booking details first.")
+    st.text("")
+   # Inject custom CSS for smaller font and tighter layout
+    st.markdown("""
+        <style>
+        .element-container:has(.streamlit-expander) {
+            margin-bottom: 0.5rem;
+        }
+        .streamlit-expanderHeader {
+            font-size: 0.9rem;
+        }
+        .streamlit-expanderContent {
+            font-size: 0.85rem;
+            padding: 0.5rem 1rem;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    with st.container():
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            with st.expander("🍽️ Restaurants"):
+                st.markdown("""
+                - Bella Italia  
+                - Spice Symphony  
+                - Tokyo Ramen House  
+                - Saffron Grill  
+                - El Toro Loco  
+                - Noodle Bar  
+                - Le Petit Bistro  
+                - Tandoori Nights  
+                - Green Leaf Cafe  
+                - Ocean Pearl  
+                - Mama Mia Pizza  
+                - The Dumpling Den  
+                - Bangkok Express  
+                - Curry Kingdom  
+                - The Garden Table  
+                - Skyline Dine  
+                - Pasta Republic  
+                - Street Tacos Co  
+                - Miso Hungry  
+                - Chez Marie
+                """)
+
+        with col2:
+            with st.expander("🌎 Cuisines"):
+                st.markdown("""
+                - Italian  
+                - French  
+                - Chinese  
+                - Japanese  
+                - Indian  
+                - Mexican  
+                - Thai  
+                - Healthy  
+                - Fusion
+                """)
+
+        with col3:
+            with st.expander("✨ Special Features"):
+                st.markdown("""
+                - Pet-Friendly  
+                - Live Music  
+                - Rooftop View  
+                - Outdoor Seating  
+                - Private Dining
+                """)
+
+
+
+
+# --- Display previous chat history (before new input) ---
+
+for msg in st.session_state.chat_history:
+    # Check if both 'role' and 'message' are not None
+    if msg['role'] is not None and msg['message'] is not None:
+        with st.chat_message(msg['role']):
+            st.markdown(msg['message'])
+
+user_input = st.chat_input("Ask something about restaurants or reservations(eg. Tell me some best rated Italian cuisine restaurants)...")
+if user_input:
+    # Show user message instantly
+    with st.chat_message("user"):
+        st.markdown(user_input)
+    st.session_state.chat_history.append({'role': 'user', 'message': user_input})
+
+    # Prepare conversation context
+    history_prompt = st.session_state.last_assistant_reply
+
+     # Store possible user info
+    user_info = store_user_info(user_input,history_prompt,store_user_info_prompt,client)
+    if user_info:
+        st.session_state.user_data.update(user_info)
+    # st.rerun()
+
+    # Detect intent
+    intent = determine_intent(user_input,determine_intent_prompt,client)
+    # st.write(intent)
+    if intent == "RUBBISH":
+        # Display user data for confirmation instead of invoking LLM
+        with st.chat_message("assistant"):
+            st.markdown("❌ Sorry, I didn't understand that. Could you rephrase your request?")
+        st.session_state.chat_history.append({
+            'role': 'assistant',
+            'message': "❌ Sorry, I didn't understand that. Could you rephrase your request?"
+        })
+       
+        st.stop()
+
+        # Generate assistant reply
+    required_keys = ["restaurant_name", "user_name", "contact", "party_size", "time"]
+    user_data_complete = all(
+    k in st.session_state.user_data and st.session_state.user_data[k] not in [None, "", "NULL"]
+    for k in required_keys
+)
+
+
+    if user_data_complete and intent != "BOOK":
+       
+        # Format user data as a Markdown bullet list
+        user_details = "\n".join([f"- **{key.capitalize()}**: {value}" for key, value in st.session_state.user_data.items()])
+        
+        with st.chat_message("assistant"):
+            st.markdown("✅ I have all the details needed for your reservation:")
+            st.markdown(user_details)
+            st.markdown("If everything looks good, please type **`book`** to confirm the reservation.")
+        
+        st.session_state.chat_history.append({
+            'role': 'assistant',
+            'message': f"✅ I have all the details needed for your reservation:\n{user_details}\nPlease type **`book`** to confirm."
+        })
+        st.session_state.last_assistant_reply = "I have all the reservation details. Waiting for confirmation..."
+        st.rerun()
+        st.stop()
+
+    
+   
+
+    response_summary = None
+       
+    if intent == "SELECT":
+        response_summary=handle_query(user_input, st.session_state.full_vector_db, client)
+        
+        # First try semantic search
+        semantic_results = {}
+        
+        # Search across all collections
+        restaurant_results = st.session_state.full_vector_db.semantic_search(user_input, "restaurants")
+        table_results = st.session_state.full_vector_db.semantic_search(user_input, "tables")
+        slot_results = st.session_state.full_vector_db.semantic_search(user_input, "slots")
+        
+        if not is_large_output_request(user_input) and any([restaurant_results, table_results, slot_results]):
+            semantic_results = {
+                "restaurants": restaurant_results,
+                "tables": table_results,
+                "slots": slot_results
+            }
+            # Format semantic results
+            summary = []
+            for category, items in semantic_results.items():
+                if items:
+                    summary.append(f"Found {len(items)} relevant {category}:")
+                    summary.extend([f"- {item['name']}" if 'name' in item else f"- {item}" 
+                                for item in items[:3]])
+            st.write("### Semantic Search used")
+            response_summary = "\n".join(summary)
+        else:
+            # Fall back to SQL generation for large or exact output requests
+            sql = generate_sql_query_v2(user_input,SCHEMA_DESCRIPTIONS, history_prompt, vector_db, client)
+            result = execute_query(sql)
+            response_summary = interpret_result_v2(result, user_input, sql)
+
+            
+    
+        # sql = generate_sql_query_v2(user_input,history_prompt, vector_db, client)
+        # result = execute_query(sql)
+        # response_summary=interpret_result_v2(result, user_input, sql)
+        # if isinstance(result, pd.DataFrame):
+        #     response_summary = interpret_sql_result(user_input, sql_query, result)
+
+    
+    elif intent == "BOOK":
+        required_keys = ["restaurant_name", "user_name", "contact", "party_size", "time"]
+        if all(st.session_state.user_data.get(k) is not None for k in required_keys):
+            booking_conn = None
+            try:
+                user_data = st.session_state.user_data
+                party_size = int(user_data["party_size"])
+                tables_needed = -(-party_size // 4)
+
+                booking_conn = sqlite3.connect("db/restaurant_reservation.db")
+                booking_cursor = booking_conn.cursor()
+
+                booking_cursor.execute("SELECT id FROM restaurants WHERE LOWER(name) = LOWER(?)", (user_data["restaurant_name"],))
+                restaurant_row = booking_cursor.fetchone()
+                if not restaurant_row:
+                    raise Exception("Restaurant not found.")
+                restaurant_id = restaurant_row[0]
+
+                booking_cursor.execute("""
+                    SELECT t.id AS table_id, s.id AS slot_id
+                    FROM tables t
+                    JOIN slots s ON t.id = s.table_id
+                    WHERE t.restaurant_id = ?
+                    AND s.hour = ?
+                    AND s.date = '2025-05-12'
+                    AND s.is_reserved = 0
+                    LIMIT ?
+                """, (restaurant_id, user_data["time"], tables_needed))
+                available = booking_cursor.fetchall()
+                # Debugging output
+                
+                if len(available) < tables_needed:
+                    raise Exception("Not enough available tables.")
+
+                booking_cursor.execute("""
+                    INSERT INTO reservations (restaurant_id, user_name, contact, date, time, party_size)
+                    VALUES (?, ?, ?, '2025-05-12', ?, ?)
+                """, (restaurant_id, user_data["user_name"], user_data["contact"], user_data["time"], party_size))
+                reservation_id = booking_cursor.lastrowid
+
+                for table_id, _ in available:
+                    booking_cursor.execute("INSERT INTO reservation_tables (reservation_id, table_id) VALUES (?, ?)", (reservation_id, table_id))
+
+                slot_ids = [slot_id for _, slot_id in available]
+                booking_cursor.executemany("UPDATE slots SET is_reserved = 1 WHERE id = ?", [(sid,) for sid in slot_ids])
+
+                booking_conn.commit()
+                # Fetch the restaurant name to confirm
+                booking_cursor.execute("SELECT name FROM restaurants WHERE id = ?", (restaurant_id,))
+                restaurant_name = booking_cursor.fetchone()[0]
+
+                # Prepare confirmation details
+                confirmation_msg = (
+                    f"✅ Booking processed successfully!\n\n"
+                    f"📍 Restaurant: **{restaurant_name}**\n"
+                    f"⏰ Time: **{user_data['time']} on 2025-05-12**\n"
+                    f"🍽️ Tables Booked: **{tables_needed}**\n"
+                    f"🆔 Reservation ID: **{reservation_id}**\n\n"
+                    f"👉 Please mention this Reservation ID at the restaurant reception when you arrive."
+                )
+
+                response_summary = confirmation_msg
+                st.success(response_summary)
+                st.session_state.chat_history.append({'role': 'assistant', 'message': response_summary})
+                response_summary="✅ Booking processed successfully."
+                st.session_state.user_data["restaurant_name"]=None
+                st.session_state.user_data["party_size"]=None
+                st.session_state.user_data["time"]=None
+                st.session_state.last_assistant_reply=""
+            except Exception as e:
+                if booking_conn:
+                    booking_conn.rollback()
+                response_summary = f"❌ Booking failed: {e}"
+                st.error(response_summary)
+            finally:
+                if booking_conn:
+                    booking_cursor=None
+                    booking_conn.close()
+        else:
+            st.markdown("⚠️ Missing user information. Please provide all booking details first.")
+            response_summary = "⚠️ Missing user information. Please provide all booking details first."
+
+
+    elif intent == "GREET":
+        response_summary = "👋 Hello! How can I help you with your restaurant reservation today?"
+
+    elif intent == "RUBBISH":
+        response_summary = "❌ Sorry, I didn't understand that. Could you rephrase your request?"
+
+    # Generate assistant reply
+    if response_summary!="✅ Booking processed successfully.":
+        follow_up = generate_reservation_conversation(
+        user_input,
+        history_prompt,
+        response_summary or "Info stored.",
+        json.dumps(st.session_state.user_data),generate_reservation_conversation_prompt,client
+    )
+    else:
+        follow_up="Thanks for booking with FoodieSpot restaurant chain, I could assist you in new booking, also I could tell about restaurant features, pricing, etc... "
+
+    # Show assistant reply instantly
+    with st.chat_message("assistant"):
+        st.markdown(follow_up)
+    
+    st.session_state.chat_history.append({'role': 'assistant', 'message': follow_up})
+    # Update it after assistant speaks
+    st.session_state.last_assistant_reply = follow_up
+    st.rerun()
+    # Reset if booking done
+    
+

efficiency_log.txt

@@ -0,0 +1,141 @@
+Function: store_user_info
+Prompt tokens: 521
+Completion tokens: 26
+Total tokens: 547
+Prompt: You are a helpful assistant. Extract relevant user information from this user statement:
+"Hi"
+
+Previously collected data in json: {"restaurant_name": null, "user_name": null, "contact": null, "party_size": null, "time": null}
+Always remember this json data, you need to update this based on user statement.
+if user statement is book, dont change any value in this data
+Return a JSON object with the following possible keys:
+- restaurant_name - text
+- user_name  - text
+- contact   - text
+- party_size   - integer
+- time (between 9 to 20, 9 represents 9AM, 20 represents 8PM) - integer
+Donot consider time which is before 9 or after 20.
+Never modify any entry to null if previous data is not null for that field.
+Update the previous data with any new fields found. Do not make previously known fields unless you are sure the user wants to change them.
+Respond ONLY with a single valid JSON object.
+important rules:
+- "restaurant_name": Must always match from this list:  
+  Bella Italia, Spice Symphony, Tokyo Ramen House, Saffron Grill, El Toro Loco, Noodle Bar, Le Petit Bistro, Tandoori Nights, Green Leaf Cafe, Ocean Pearl, Mama Mia Pizza, The Dumpling Den, Bangkok Express, Curry Kingdom, The Garden Table, Skyline Dine, Pasta Republic, Street Tacos Co, Miso Hungry, Chez Marie
+
+
+If in previously collected data, the restaurant_name is there but not in this list as the exact spelling or not with correct casing, replace it with the correct one.
+
+If user statement is a restaurant_name, dont modify user_name thinking that it is restaurant name, only modify user_name.
+- "user_name":
+  - Only extract if the input clearly states a name like “My name is ...” or “This is ...”
+  - Do not extract from greetings like “Hi”, “Hello”, “Hey”, “Yo”, “Good evening”
+  - Do not invent names based on formatting or assumptions
+
+Output format rules:
+-Make sure restaurant_name matches from the list given
+- Return only valid JSON — starting with { and ending with }
+- All keys and values must be in double quotes
+- Include all 5 keys in the output 
+- No markdown, comments, or explanation in output, just give a json
+---
+Function: store_user_info
+Prompt tokens: 521
+Completion tokens: 63
+Total tokens: 584
+Prompt: You are a helpful assistant. Extract relevant user information from this user statement:
+"Hi"
+
+Previously collected data in json: {"restaurant_name": null, "user_name": null, "contact": null, "party_size": null, "time": null}
+Always remember this json data, you need to update this based on user statement.
+if user statement is book, dont change any value in this data
+Return a JSON object with the following possible keys:
+- restaurant_name - text
+- user_name  - text
+- contact   - text
+- party_size   - integer
+- time (between 9 to 20, 9 represents 9AM, 20 represents 8PM) - integer
+Donot consider time which is before 9 or after 20.
+Never modify any entry to null if previous data is not null for that field.
+Update the previous data with any new fields found. Do not make previously known fields unless you are sure the user wants to change them.
+Respond ONLY with a single valid JSON object.
+important rules:
+- "restaurant_name": Must always match from this list:  
+  Bella Italia, Spice Symphony, Tokyo Ramen House, Saffron Grill, El Toro Loco, Noodle Bar, Le Petit Bistro, Tandoori Nights, Green Leaf Cafe, Ocean Pearl, Mama Mia Pizza, The Dumpling Den, Bangkok Express, Curry Kingdom, The Garden Table, Skyline Dine, Pasta Republic, Street Tacos Co, Miso Hungry, Chez Marie
+
+
+If in previously collected data, the restaurant_name is there but not in this list as the exact spelling or not with correct casing, replace it with the correct one.
+
+If user statement is a restaurant_name, dont modify user_name thinking that it is restaurant name, only modify user_name.
+- "user_name":
+  - Only extract if the input clearly states a name like “My name is ...” or “This is ...”
+  - Do not extract from greetings like “Hi”, “Hello”, “Hey”, “Yo”, “Good evening”
+  - Do not invent names based on formatting or assumptions
+
+Output format rules:
+-Make sure restaurant_name matches from the list given
+- Return only valid JSON — starting with { and ending with }
+- All keys and values must be in double quotes
+- Include all 5 keys in the output 
+- No markdown, comments, or explanation in output, just give a json
+---
+Function: determine_intent
+Prompt tokens: 257
+Completion tokens: 3
+Total tokens: 260
+Prompt: You are an intent classification assistant for a restaurant reservation system.
+
+User input: "Hi"
+
+Classify the intent as one of:
+- STORE: User shares name, contact, or reservation details (like party size or time) without asking anything.
+- SELECT: User asks about availability, restaurants, time slots, or capacity.
+- BOOK: User says only "book" (case-insensitive). Even "I want to book..." is SELECT, not BOOK.
+- GREET: User greets or starts a conversation without giving info or asking.
+- RUBBISH: Input is gibberish, irrelevant, or unrecognizable.
+
+Examples:
+- "My name is Raj" → STORE  
+- "book" → BOOK  
+- "15 people" → SELECT  
+- "Tell me best restaurants" → SELECT  
+- "7801061333" → STORE  
+- "asdfgh" → RUBBISH  
+- "Hi there" → GREET
+
+Respond with ONE word only: SELECT, STORE, BOOK, GREET, or RUBBISH. No explanation
+---
+Function: generate_reservation_conversation
+Prompt tokens: 427
+Completion tokens: 50
+Total tokens: 477
+Prompt: You are a professional restaurant reservation assistant helping a customer make a booking. Speak concisely and professionally. Unless the booking is complete, end with a helpful question.
+
+User said: "Hi"
+Always try to answer this user query.
+Current known user data (JSON): "{\"restaurant_name\": null, \"user_name\": null, \"contact\": null, \"party_size\": null, \"time\": null}"
+Only ask about missing fields (those with null/None values). Do not repeat questions for data already present.
+Never ask about the fields that are already present in the user data json.
+- user_name: user's name
+- contact: user’s phone (not for queries)
+- restaurant_name: name of restaurant
+- party_size: number of people
+- time: hour of reservation (9–20)
+
+If restaurant_name is missing, offer to suggest restaurants or cuisines. Never mention "null"—be conversational. Show known info naturally if helpful.
+
+Database info:  
+"👋 Hello! How can I help you with your restaurant reservation today?"  
+Explain this clearly based on what user said. If it says:
+- "Info Stored": thank the user and ask next missing info.
+- "✅ Booking processed successfully.": Tell thanks for booking, I could assist you in new booking, also I could tell about restaurant features, pricing, etc, dont ask anything else.
+- "❌ Booking failed: ...": explain the error simply and suggest trying again.
+- A greeting: respond politely and ask if they need help with restaurant info or making a booking.
+
+Personalize your response using available user data. Each table seats 4 people; use ceil(party_size / 4) to estimate how many are needed.
+Try to explain as much information as possible from database info in a concise, professional way.
+
+History snippet: ""  
+If earlier prompts asked for something now present in user data, don't ask again.
+
+Be helpful, efficient, and professional in tone.
+---

restaurants.json

@@ -0,0 +1,182 @@
+[
+  {
+    "id": "r001",
+    "name": "Spice Garden",
+    "location": "Downtown",
+    "cuisine": ["Indian"],
+    "capacity": 40,
+    "ambiance": "casual",
+    "available_times": ["18:00", "19:30", "21:00"]
+  },
+  {
+    "id": "r002",
+    "name": "Bella Italia",
+    "location": "Midtown",
+    "cuisine": ["Italian"],
+    "capacity": 35,
+    "ambiance": "romantic",
+    "available_times": ["17:30", "19:00", "20:30"]
+  },
+  {
+    "id": "r003",
+    "name": "Tokyo Bites",
+    "location": "Uptown",
+    "cuisine": ["Japanese"],
+    "capacity": 50,
+    "ambiance": "family",
+    "available_times": ["18:00", "19:30"]
+  },
+  {
+    "id": "r004",
+    "name": "The Global Spoon",
+    "location": "Central",
+    "cuisine": ["Indian", "Mexican", "Chinese"],
+    "capacity": 60,
+    "ambiance": "casual",
+    "available_times": ["17:00", "18:30", "20:00"]
+  },
+  {
+    "id": "r005",
+    "name": "Saffron Lounge",
+    "location": "Downtown",
+    "cuisine": ["Indian", "Persian"],
+    "capacity": 45,
+    "ambiance": "fine-dining",
+    "available_times": ["18:00", "19:30", "21:00"]
+  },
+  {
+    "id": "r006",
+    "name": "La Vida",
+    "location": "Uptown",
+    "cuisine": ["Spanish"],
+    "capacity": 30,
+    "ambiance": "romantic",
+    "available_times": ["17:30", "19:00", "20:30"]
+  },
+  {
+    "id": "r007",
+    "name": "Burger Craze",
+    "location": "Midtown",
+    "cuisine": ["American"],
+    "capacity": 25,
+    "ambiance": "casual",
+    "available_times": ["16:00", "17:00", "18:30"]
+  },
+  {
+    "id": "r008",
+    "name": "Wok Express",
+    "location": "Chinatown",
+    "cuisine": ["Chinese"],
+    "capacity": 55,
+    "ambiance": "family",
+    "available_times": ["18:00", "19:30"]
+  },
+  {
+    "id": "r009",
+    "name": "Taco Fiesta",
+    "location": "Southside",
+    "cuisine": ["Mexican"],
+    "capacity": 40,
+    "ambiance": "casual",
+    "available_times": ["17:00", "18:30", "20:00"]
+  },
+  {
+    "id": "r010",
+    "name": "Green Fork",
+    "location": "Downtown",
+    "cuisine": ["Vegan", "Organic"],
+    "capacity": 28,
+    "ambiance": "minimalist",
+    "available_times": ["17:00", "18:30", "20:00"]
+  },
+  {
+    "id": "r011",
+    "name": "The Royal Tandoor",
+    "location": "Eastside",
+    "cuisine": ["Indian"],
+    "capacity": 50,
+    "ambiance": "fine-dining",
+    "available_times": ["18:00", "19:30", "21:00"]
+  },
+  {
+    "id": "r012",
+    "name": "Ocean Grill",
+    "location": "Seaside",
+    "cuisine": ["Seafood"],
+    "capacity": 60,
+    "ambiance": "coastal",
+    "available_times": ["17:30", "19:00", "20:30"]
+  },
+  {
+    "id": "r013",
+    "name": "Le Petit Bistro",
+    "location": "Central",
+    "cuisine": ["French"],
+    "capacity": 26,
+    "ambiance": "romantic",
+    "available_times": ["18:00", "19:30"]
+  },
+  {
+    "id": "r014",
+    "name": "Fusion Point",
+    "location": "Uptown",
+    "cuisine": ["Asian", "Italian"],
+    "capacity": 48,
+    "ambiance": "modern",
+    "available_times": ["17:00", "18:30", "20:00"]
+  },
+  {
+    "id": "r015",
+    "name": "Himalayan Hearth",
+    "location": "Downtown",
+    "cuisine": ["Nepalese", "Tibetan"],
+    "capacity": 30,
+    "ambiance": "cozy",
+    "available_times": ["17:30", "19:00"]
+  },
+  {
+    "id": "r016",
+    "name": "BBQ Pitstop",
+    "location": "Westend",
+    "cuisine": ["American", "Barbecue"],
+    "capacity": 52,
+    "ambiance": "rustic",
+    "available_times": ["18:00", "19:30", "21:00"]
+  },
+  {
+    "id": "r017",
+    "name": "Curry & More",
+    "location": "Southside",
+    "cuisine": ["Indian", "Thai"],
+    "capacity": 40,
+    "ambiance": "family",
+    "available_times": ["17:00", "18:30", "20:00"]
+  },
+  {
+    "id": "r018",
+    "name": "Dolce Vita",
+    "location": "Midtown",
+    "cuisine": ["Italian", "French"],
+    "capacity": 36,
+    "ambiance": "elegant",
+    "available_times": ["18:00", "19:30", "21:00"]
+  },
+  {
+    "id": "r019",
+    "name": "K-Pot",
+    "location": "Chinatown",
+    "cuisine": ["Korean", "Hot Pot"],
+    "capacity": 42,
+    "ambiance": "lively",
+    "available_times": ["17:30", "19:00", "20:30"]
+  },
+  {
+    "id": "r020",
+    "name": "Garden Table",
+    "location": "Central",
+    "cuisine": ["Farm-to-Table", "Vegetarian"],
+    "capacity": 38,
+    "ambiance": "natural",
+    "available_times": ["17:00", "18:30", "20:00"]
+  }
+]

sticky.py

@@ -0,0 +1,44 @@
+from typing import Literal
+
+import streamlit as st
+
+MARGINS = {
+    "top": "0",
+    "bottom": "0",
+}
+
+STICKY_CONTAINER_HTML = """
+<style>
+div[data-testid="stVerticalBlock"] div:has(div.fixed-header-{i}) {{
+    position: sticky;
+    {position}: {margin};
+    background-color: white;
+    z-index: {z};
+}}
+</style>
+<div class='fixed-header-{i}'/>
+""".strip()
+
+# Not to apply the same style to multiple containers
+count = 0
+
+
+def sticky_container(
+    *,
+    height: int | None = None,
+    border: bool | None = None,
+    mode: Literal["top", "bottom"] = "top",
+    margin: str | None = None,
+    z:int |None=None
+):
+    if margin is None:
+        margin = MARGINS[mode]
+
+    global count
+    html_code = STICKY_CONTAINER_HTML.format(position=mode, margin=margin, i=count,z=z)
+    count += 1
+
+    container = st.container(height=height, border=border)
+    container.markdown(html_code, unsafe_allow_html=True)
+    return container
+

tools.py

@@ -0,0 +1,318 @@
+import sqlite3
+import inspect
+import pandas as pd
+import json
+import re
+import streamlit as st
+def log_groq_token_usage(response, prompt=None, function_name=None, filename="efficiency_log.txt"):
+    usage = response.usage
+    log_message = (
+        f"Function: {function_name or 'unknown'}\n"
+        f"Prompt tokens: {usage.prompt_tokens}\n"
+        f"Completion tokens: {usage.completion_tokens}\n"
+        f"Total tokens: {usage.total_tokens}\n"
+        f"Prompt: {prompt}\n"
+        "---\n"
+    )
+    with open(filename, "a", encoding="utf-8") as f:  # ← THIS LINE
+        f.write(log_message)
+
+import pandas as pd
+# --- Database Execution ---    
+def execute_transaction(sql_statements):
+    txn_conn = None
+    try:
+        txn_conn = sqlite3.connect("db/restaurant_reservation.db")
+        cursor = txn_conn.cursor()
+        for stmt in sql_statements:
+            cursor.execute(stmt)
+        txn_conn.commit()
+        return "✅ Booking Executed"
+    except Exception as e:
+        if txn_conn:
+            txn_conn.rollback()
+        return f"❌ Booking failed: {e}"
+    finally:
+        if txn_conn:
+            txn_conn.close()
+
+
+def execute_query(sql_query, db_path="db/restaurant_reservation.db"):
+    conn = None
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        cursor.execute(sql_query)
+        rows = cursor.fetchall()
+        columns = [desc[0] for desc in cursor.description] if cursor.description else []
+        return pd.DataFrame(rows, columns=columns)
+    except Exception as e:
+        return f"❌ Error executing query: {e}"
+    finally:
+        if conn:
+            conn.close()
+def generate_sql_query_v2(user_input,SCHEMA_DESCRIPTIONS,history_prompt, vector_db, client, use_cache=False):
+    # Get relevant schema elements
+    relevant_tables = vector_db.get_relevant_schema(user_input)
+    schema_prompt = "\n".join([f"Table {table}:\n{SCHEMA_DESCRIPTIONS[table]}" for table in relevant_tables])
+    # Cache check
+    cache_key = f"query:{user_input[:50]}"
+    if use_cache and (cached := cache.get(cache_key)):
+        return cached.decode()
+    # Generate SQL with Groq
+    prompt = f"""Based on these tables:
+{schema_prompt}
+Previous assistant reply:
+{history_prompt}
+Convert this request to SQL: {user_input}
+
+Only return the SQL query, nothing else."""
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that only returns SQL queries."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.3,
+        max_tokens=200
+    )
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+    sql = response.choices[0].message.content.strip()
+    if use_cache:
+        cache.setex(cache_key, 3600, sql)
+    return sql
+def interpret_result_v2(result, user_query, sql_query,client):
+    if isinstance(result, str):
+        return result
+    try:
+        # Compress to essential columns if possible
+        cols = [c for c in result.columns if c in ['name', 'cuisine', 'location', 'seating_capacity', 'rating', 'address', 'contact', 'price_range', 'special_features', 'capacity', 'date', 'hour']]
+        if cols:
+            compressed = result[cols]
+        else:
+            compressed = result
+        json_data = compressed.to_json(orient='records', indent=2)
+        # Summarize with Groq
+        prompt = f"""User query: {user_query}
+SQL query: {sql_query}
+Result data (JSON): {json_data}
+
+Summarize the results for the user."""
+        response = client.chat.completions.create(
+            model="llama3-8b-8192",
+            messages=[
+                {"role": "system", "content": "Summarize database query results for a restaurant reservation assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.3,
+            max_tokens=300
+        )
+        log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        return f"Error interpreting results: {e}"
+    
+def handle_query(user_input, vector_db, client):
+    try:
+        # First try semantic search
+        semantic_results = {}
+        
+        # Search across all collections
+        restaurant_results = vector_db.semantic_search(user_input, "restaurants")
+        table_results = vector_db.semantic_search(user_input, "tables")
+        slot_results = vector_db.semantic_search(user_input, "slots")
+        
+        if any([restaurant_results, table_results, slot_results]):
+            semantic_results = {
+                "restaurants": restaurant_results,
+                "tables": table_results,
+                "slots": slot_results
+            }
+            
+            # Format semantic results
+            summary = []
+            for category, items in semantic_results.items():
+                if items:
+                    summary.append(f"Found {len(items)} relevant {category}:")
+                    summary.extend([f"- {item['name']}" if 'name' in item else f"- {item}" 
+                                  for item in items[:3]])
+            
+            return "\n".join(summary)
+        else:
+            # Fall back to SQL generation
+            sql = generate_sql_query_v2(user_input, vector_db, client)
+            result = execute_query(sql)
+            return interpret_result_v2(result, user_input, sql,client)
+            
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def is_large_output_request(query):
+    query = query.lower()
+    # List of single words and multi-word phrases (as lists)
+    triggers = [
+        ['all'], ['every'], ['entire'], ['complete'], ['full'], ['each'],
+        ['list'], ['show'], ['display'], ['give', 'me'], ['get'],
+        ['every', 'single'], ['each', 'and', 'every'],
+        ['whole'], ['total'], ['collection'], ['set'],
+        ['no', 'filters'], ['without', 'filters'],
+        ['everything'], ['entirety'],
+        ['comprehensive'], ['exhaustive'], ['record'],
+        ['don\'t', 'filter'], ['without', 'limitations']
+    ]
+    query_words = query.split()
+    for trigger in triggers:
+        if all(word in query_words for word in trigger):
+            return True
+    return False
+
+
+def generate_reservation_conversation(user_query, history_prompt, sql_summary, user_data,generate_reservation_conversation_prompt,client):
+    words = history_prompt.split() if history_prompt else []
+    if len(words) > 25:
+        history_prompt_snippet = " ".join(words[:15]) + " ... " + " ".join(words[-10:])
+    else:
+        history_prompt_snippet = " ".join(words)
+
+    # Serialize user_data as pretty JSON for readability in prompt
+    user_data_json = json.dumps(user_data, indent=2)
+
+    prompt = generate_reservation_conversation_prompt.format(
+        user_query=user_query,
+        user_data=user_data_json,
+        sql_summary=sql_summary,
+        history_prompt_snippet=history_prompt_snippet
+    )
+
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[
+            {"role": "system", "content": "You are a helpful restaurant reservation assistant."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.4
+    )
+
+    if not response.choices:
+        return "Sorry, I couldn't generate a response right now."
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+
+    return response.choices[0].message.content.strip()
+
+ 
+# --- Helper Functions ---
+
+def determine_intent(user_input,determine_intent_prompt,client):
+    prompt = determine_intent_prompt.format(user_input=user_input)
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[
+            {"role": "system", "content": "Classify user intent into SELECT, STORE, BOOK, GREET, or RUBBISH based on message content."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0
+    )
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+    return response.choices[0].message.content.strip().upper()
+
+
+
+def store_user_info(user_input,history_prompt,store_user_info_prompt, client):
+    # words = history_prompt.split()
+    # if len(words) > 25:
+    #     history_prompt_snippet = " ".join(words[:15]) + " ... " + " ".join(words[-10:])
+    # else:
+    #     history_prompt_snippet = " ".join(words)
+    previous_info = json.dumps(st.session_state.user_data)
+    # st.json(previous_info)
+    prompt = store_user_info_prompt.format(previous_info=previous_info,user_input=user_input)
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[{"role": "system", "content": "Extract or update user booking info in JSON."},
+                  {"role": "user", "content": prompt}],
+        temperature=0.3
+    )
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+
+    try:
+        # Print raw LLM output for inspection
+        raw_output = response.choices[0].message.content
+        # st.subheader("🧠 Raw LLM Response")
+        # st.write(raw_output)
+
+        # Extract JSON substring from anywhere in the response
+        json_match = re.search(r'{[\s\S]*?}', raw_output)
+        if not json_match:
+            return None
+            # raise ValueError("No JSON object found in response.")
+
+        json_str = json_match.group()
+
+        # Show the extracted JSON string
+        # st.subheader("📦 Extracted JSON String")
+        # st.code(json_str, language="json")
+
+        # Safely parse using json.loads
+        parsed = json.loads(json_str)
+
+        # Display the parsed result
+        # st.subheader("✅ Parsed JSON Object")
+        # st.json(parsed)
+
+        return parsed
+
+    except Exception as e:
+        st.error(f"⚠️ Failed to parse JSON: {e}")
+        return {}
+    
+def generate_sql_query(user_input,restaurant_name,party_size,time, history_prompt, schema_prompt, client):
+    words = history_prompt.split()
+    if len(words) > 25:
+        history_prompt_snippet = " ".join(words[:15]) + " ... " + " ".join(words[-10:])
+    else:
+        history_prompt_snippet = " ".join(words)
+    prompt = schema_prompt.format(
+        history_prompt=history_prompt,
+        user_input=user_input
+    )
+
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that only returns SQL queries."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.3
+    )
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+    raw_sql = response.choices[0].message.content.strip()
+    extracted_sql = re.findall(r"(SELECT[\s\S]+?)(?:;|$)", raw_sql, re.IGNORECASE)
+    sql_query = extracted_sql[0].strip() + ";" if extracted_sql else raw_sql
+       
+    return sql_query
+    
+def interpret_sql_result(user_query, sql_query, result,interpret_sql_result_prompt, client):
+    if isinstance(result, pd.DataFrame):
+        # Convert DataFrame to list of dicts
+        result_dict = result.to_dict(orient="records")
+    else:
+        # Fall back to raw string if not a DataFrame
+        result_dict = result
+
+    prompt = interpret_sql_result_prompt.format(
+        user_query=user_query,
+        sql_query=sql_query,
+        result_str=json.dumps(result_dict, indent=2)  # Pass as formatted JSON string
+    )
+    
+    response = client.chat.completions.create(
+        model="llama3-8b-8192",
+        messages=[
+            {"role": "system", "content": "You summarize database query results for a restaurant reservation assistant."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.3
+    )
+    log_groq_token_usage(response,prompt, function_name=inspect.currentframe().f_code.co_name)
+    return response.choices[0].message.content.strip()

ui_utils.py

@@ -0,0 +1,150 @@
+from typing import Literal
+
+import streamlit as st
+from streamlit.components.v1 import html
+
+"""
+st_fixed_container consist of two parts - fixed container and opaque container.
+Fixed container is a container that is fixed to the top or bottom of the screen.
+When transparent is set to True, the container is typical `st.container`, which is transparent by default.
+When transparent is set to False, the container is custom opaque_container, that updates its background color to match the background color of the app.
+Opaque container is a helper class, but can be used to create more custom views. See main for examples.
+"""
+OPAQUE_CONTAINER_CSS = """
+:root {{
+    --background-color: #ffffff; /* Default background color */
+}}
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.opaque-container-{id}):not(:has(div.not-opaque-container)) div[data-testid="stVerticalBlock"]:has(div.opaque-container-{id}):not(:has(div.not-opaque-container)) > div[data-testid="stVerticalBlockBorderWrapper"] {{
+    background-color: var(--background-color);
+    width: 100%;
+}}
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.opaque-container-{id}):not(:has(div.not-opaque-container)) div[data-testid="stVerticalBlock"]:has(div.opaque-container-{id}):not(:has(div.not-opaque-container)) > div[data-testid="element-container"] {{
+    display: none;
+}}
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.not-opaque-container):not(:has(div[class^='opaque-container-'])) {{
+    display: none;
+}}
+""".strip()
+
+OPAQUE_CONTAINER_JS = """
+const root = parent.document.querySelector('.stApp');
+let lastBackgroundColor = null;
+function updateContainerBackground(currentBackground) {
+    parent.document.documentElement.style.setProperty('--background-color', currentBackground);
+    ;
+}
+function checkForBackgroundColorChange() {
+    const style = window.getComputedStyle(root);
+    const currentBackgroundColor = style.backgroundColor;
+    if (currentBackgroundColor !== lastBackgroundColor) {
+        lastBackgroundColor = currentBackgroundColor; // Update the last known value
+        updateContainerBackground(lastBackgroundColor);
+    }
+}
+const observerCallback = (mutationsList, observer) => {
+    for(let mutation of mutationsList) {
+        if (mutation.type === 'attributes' && (mutation.attributeName === 'class' || mutation.attributeName === 'style')) {
+            checkForBackgroundColorChange();
+        }
+    }
+};
+const main = () => {
+    checkForBackgroundColorChange();
+    const observer = new MutationObserver(observerCallback);
+    observer.observe(root, { attributes: true, childList: false, subtree: false });
+}
+// main();
+document.addEventListener("DOMContentLoaded", main);
+""".strip()
+
+
+def st_opaque_container(
+    *,
+    height: int | None = None,
+    border: bool | None = None,
+    key: str | None = None,
+):
+    global opaque_counter
+
+    opaque_container = st.container()
+    non_opaque_container = st.container()
+    css = OPAQUE_CONTAINER_CSS.format(id=key)
+    with opaque_container:
+        html(f"<script>{OPAQUE_CONTAINER_JS}</script>", scrolling=False, height=0)
+        st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+        st.markdown(
+            f"<div class='opaque-container-{key}'></div>",
+            unsafe_allow_html=True,
+        )
+    with non_opaque_container:
+        st.markdown(
+            f"<div class='not-opaque-container'></div>",
+            unsafe_allow_html=True,
+        )
+
+    return opaque_container.container(height=height, border=border)
+
+
+FIXED_CONTAINER_CSS = """
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.fixed-container-{id}):not(:has(div.not-fixed-container)){{
+    background-color: transparent;
+    position: {mode};
+    width: inherit;
+    background-color: inherit;
+    {position}: {margin};
+    z-index: 999;
+}}
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.fixed-container-{id}):not(:has(div.not-fixed-container)) div[data-testid="stVerticalBlock"]:has(div.fixed-container-{id}):not(:has(div.not-fixed-container)) > div[data-testid="element-container"] {{
+    display: none;
+}}
+div[data-testid="stVerticalBlockBorderWrapper"]:has(div.not-fixed-container):not(:has(div[class^='fixed-container-'])) {{
+    display: none;
+}}
+""".strip()
+
+MARGINS = {
+    "top": "0",
+    "bottom": "0",
+}
+
+
+def st_fixed_container(
+    *,
+    height: int | None = None,
+    border: bool | None = None,
+    mode: Literal["fixed", "sticky"] = "fixed",
+    position: Literal["top", "bottom"] = "top",
+    margin: str | None = None,
+    transparent: bool = False,
+    key: str | None = None,
+):
+    if margin is None:
+        margin = MARGINS[position]
+    global fixed_counter
+    fixed_container = st.container()
+    non_fixed_container = st.container()
+    css = FIXED_CONTAINER_CSS.format(
+        mode=mode,
+        position=position,
+        margin=margin,
+        id=key,
+    )
+    with fixed_container:
+        st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+        st.markdown(
+            f"<div class='fixed-container-{key}'></div>",
+            unsafe_allow_html=True,
+        )
+    with non_fixed_container:
+        st.markdown(
+            f"<div class='not-fixed-container'></div>",
+            unsafe_allow_html=True,
+        )
+
+    with fixed_container:
+        if transparent:
+            return st.container(height=height, border=border)
+
+        return st_opaque_container(height=height, border=border, key=f"opaque_{key}")
+
+

var.py

@@ -0,0 +1,142 @@
+import chromadb
+import sqlite3
+import hashlib
+import pandas as pd
+from sentence_transformers import SentenceTransformer 
+#--- Initialize ChromaDB and SentenceTransformer ---
+SCHEMA_DESCRIPTIONS = {
+    "restaurants": """Table restaurants contains restaurant details:
+    - id: unique identifier
+    - name: restaurant name
+    - cuisine: type of cuisine
+    - location: area or neighborhood
+    - seating_capacity: total seats
+    - rating: average rating
+    - address: full address
+    - contact: phone or email
+    - price_range: price category
+    - special_features: amenities or highlights""",
+    "tables": """Table tables contains table details:
+    - id: unique identifier
+    - restaurant_id: links to restaurants.id
+    - capacity: number of seats (default 4)""",
+    "slots": """Table slots contains reservation time slots:
+    - id: unique identifier
+    - table_id: links to tables.id
+    - date: reservation date
+    - hour: reservation hour
+    - is_reserved: 0=available, 1=booked"""
+}
+class SchemaVectorDB:
+    def __init__(self):
+        self.client = chromadb.Client()
+        self.collection = self.client.get_or_create_collection("schema")
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        for idx, (name, desc) in enumerate(SCHEMA_DESCRIPTIONS.items()):
+            self.collection.add(ids=str(idx), documents=desc, metadatas={"name": name})
+
+    def get_relevant_schema(self, query, k=2):
+        query_embedding = self.model.encode(query).tolist()
+        results = self.collection.query(query_embeddings=[query_embedding], n_results=k)
+        # results['metadatas'] is a list of lists: [[{...}, {...}], ...]
+        # We only have one query, so grab the first list
+        metadatas = results['metadatas'][0] if results['metadatas'] else []
+        return [m['name'] for m in metadatas if m and 'name' in m]
+
+
+
+
+
+
+class FullVectorDB:
+    def __init__(self):
+        self.client = chromadb.PersistentClient(path="db/chroma")
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Get existing collections or create if not exist
+        self.restaurants_col = self.client.get_or_create_collection("restaurants")
+        self.tables_col = self.client.get_or_create_collection("tables")
+        self.slots_col = self.client.get_or_create_collection("slots")
+        
+        # Initialize only if collections are empty
+        if len(self.restaurants_col.get()['ids']) == 0:
+            self._initialize_collections()
+
+    def _row_to_text(self, row):
+        return ' '.join(str(v) for v in row.values if pd.notnull(v))
+
+    def _row_hash(self, row):
+        return hashlib.sha256(str(row.values).encode()).hexdigest()
+
+    def _initialize_collections(self):
+        conn = sqlite3.connect("db/restaurant_reservation.db")
+        
+        # Create external changelog table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS chroma_changelog (
+                id INTEGER PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                content_hash TEXT,
+                UNIQUE(table_name, record_id)
+            )
+        """)
+        conn.commit()
+
+        # Process tables
+        self._process_table(conn, "restaurants", self.restaurants_col)
+        self._process_table(conn, "tables", self.tables_col)
+        self._process_table(conn, "slots", self.slots_col)
+        
+        conn.close()
+
+    def _process_table(self, conn, table_name, collection):
+        # Get existing records from Chroma
+        existing_ids = set(collection.get()['ids'])
+        
+        # Get all records from SQLite with hash
+        df = pd.read_sql(f"SELECT * FROM {table_name}", conn)
+        
+        # Process each row
+        for _, row in df.iterrows():
+            chroma_id = f"{table_name}_{row['id']}"
+            current_hash = self._row_hash(row)
+            
+            # Check if exists in changelog
+            changelog = pd.read_sql(f"""
+                SELECT content_hash 
+                FROM chroma_changelog 
+                WHERE table_name = ? AND record_id = ?
+            """, conn, params=(table_name, row['id']))
+            
+            # Skip if hash matches
+            if not changelog.empty and changelog.iloc[0]['content_hash'] == current_hash:
+                continue
+                
+            # Generate embedding
+            embedding = self.model.encode(self._row_to_text(row))
+            
+            # Update Chroma
+            collection.upsert(
+                ids=[chroma_id],
+                embeddings=[embedding.tolist()],
+                metadatas=[row.to_dict()]
+            )
+            
+            # Update changelog
+            conn.execute("""
+                INSERT OR REPLACE INTO chroma_changelog 
+                (table_name, record_id, content_hash)
+                VALUES (?, ?, ?)
+            """, (table_name, row['id'], current_hash))
+            conn.commit()
+
+    def semantic_search(self, query, collection_name, k=5):
+        query_embedding = self.model.encode(query).tolist()
+        collection = getattr(self, f"{collection_name}_col")
+        results = collection.query(
+            query_embeddings=[query_embedding],
+            n_results=k,
+            include=["metadatas"]
+        )
+        return results['metadatas'][0]