Upload 37 files

.gitattributes

@@ -1,2 +1,19 @@
 # Auto detect text files and perform LF normalization
 * text=auto
+assets/all_resto.png filter=lfs diff=lfs merge=lfs -text
+assets/booking_successful.png filter=lfs diff=lfs merge=lfs -text
+assets/general_conv_info_through_chat.png filter=lfs diff=lfs merge=lfs -text
+assets/greet_general_convo.png filter=lfs diff=lfs merge=lfs -text
+assets/landing.png filter=lfs diff=lfs merge=lfs -text
+assets/mermaid-1.png filter=lfs diff=lfs merge=lfs -text
+assets/mermaid.png filter=lfs diff=lfs merge=lfs -text
+assets/name_entering.png filter=lfs diff=lfs merge=lfs -text
+assets/ready_to_book.png filter=lfs diff=lfs merge=lfs -text
+assets/rubbish.PNG filter=lfs diff=lfs merge=lfs -text
+assets/some_results.PNG filter=lfs diff=lfs merge=lfs -text
+db/chroma/0f1c557e-a6e2-45cb-8079-0720b4f2093f/data_level0.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/45948c9b-58d5-4762-9fd1-cf9b5925ba84/data_level0.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/b97e1f95-8691-4375-b2f8-2f2e96d82a8c/data_level0.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/b97e1f95-8691-4375-b2f8-2f2e96d82a8c/index_metadata.pickle filter=lfs diff=lfs merge=lfs -text
+db/chroma/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+db/restaurant_reservation.db filter=lfs diff=lfs merge=lfs -text

db/chroma/0f1c557e-a6e2-45cb-8079-0720b4f2093f/data_level0.bin

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

db/chroma/45948c9b-58d5-4762-9fd1-cf9b5925ba84/data_level0.bin

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

db/chroma/b97e1f95-8691-4375-b2f8-2f2e96d82a8c/data_level0.bin

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

db/chroma/b97e1f95-8691-4375-b2f8-2f2e96d82a8c/index_metadata.pickle

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

db/chroma/chroma.sqlite3

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

db/create_base.py

@@ -0,0 +1,64 @@
+import sqlite3
+
+# Connect to the SQLite database
+conn = sqlite3.connect("restaurant_reservation.db")
+cursor = conn.cursor()
+
+# Create tables if they do not exist
+cursor.executescript("""
+CREATE TABLE IF NOT EXISTS restaurants (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    cuisine TEXT,
+    location TEXT,
+    seating_capacity INTEGER,
+    rating REAL,
+    address TEXT,
+    contact TEXT,
+    price_range TEXT,
+    special_features TEXT
+);
+
+CREATE TABLE IF NOT EXISTS tables (
+    id TEXT PRIMARY KEY,
+    restaurant_id TEXT,
+    capacity INTEGER DEFAULT 4,
+    FOREIGN KEY (restaurant_id) REFERENCES restaurants(id)
+);
+
+CREATE TABLE IF NOT EXISTS slots (
+    id TEXT PRIMARY KEY,
+    table_id TEXT,
+    date TEXT,
+    hour INTEGER,
+    is_reserved INTEGER DEFAULT 0,
+    FOREIGN KEY (table_id) REFERENCES tables(id)
+);
+
+CREATE TABLE IF NOT EXISTS reservations (
+    id TEXT PRIMARY KEY,
+    restaurant_id TEXT,
+    user_name TEXT,
+    contact TEXT,
+    date TEXT,
+    time INTEGER,
+    party_size INTEGER,
+    FOREIGN KEY (restaurant_id) REFERENCES restaurants(id)
+);
+
+CREATE TABLE IF NOT EXISTS reservation_tables (
+    id TEXT PRIMARY KEY,
+    reservation_id TEXT,
+    table_id TEXT,
+    FOREIGN KEY (reservation_id) REFERENCES reservations(id),
+    FOREIGN KEY (table_id) REFERENCES tables(id)
+);
+""")
+
+# Commit the changes
+conn.commit()
+
+# Close the connection
+conn.close()
+
+print("Tables have been created successfully!")

db/create_slots.py

@@ -0,0 +1,33 @@
+import sqlite3
+import uuid
+from datetime import datetime
+
+# Connect to your SQLite DB
+conn = sqlite3.connect("restaurant_reservation.db")
+cursor = conn.cursor()
+
+# Get all table IDs
+cursor.execute("SELECT id FROM tables")
+table_ids = [row[0] for row in cursor.fetchall()]
+
+# Define the time range and current date
+start_hour = 9  # 9AM
+end_hour = 21   # 9PM
+
+# Prepare slot entries
+slot_entries = []
+for table_id in table_ids:
+    for hour in range(start_hour, end_hour):
+        slot_id = str(uuid.uuid4())
+        slot_entries.append((slot_id, table_id, "2025-05-12", hour, 0))  # is_reserved = 0
+
+# Insert into slots table
+cursor.executemany("""
+    INSERT INTO slots (id, table_id, date, hour, is_reserved)
+    VALUES (?, ?, ?, ?, ?)
+""", slot_entries)
+
+conn.commit()
+conn.close()
+
+print("✅ Slots successfully added for all tables for today.")

db/dbmodify.py

@@ -0,0 +1,54 @@
+# import sqlite3
+
+# conn = sqlite3.connect("restaurant_reservation.db")
+# cursor = conn.cursor()
+
+# # Drop the existing empty tables
+# cursor.execute("DROP TABLE IF EXISTS reservations;")
+# cursor.execute("DROP TABLE IF EXISTS reservation_tables;")
+
+# # Recreate the tables with AUTOINCREMENT for `id`
+# cursor.execute("""
+# CREATE TABLE reservations (
+#     id INTEGER PRIMARY KEY AUTOINCREMENT,
+#     restaurant_id TEXT,
+#     user_name TEXT,
+#     contact TEXT,
+#     date TEXT,          -- Hard coded to 2025-05-12
+#     time TEXT,
+#     party_size INTEGER
+# );
+# """)
+
+# cursor.execute("""
+# CREATE TABLE reservation_tables (
+#     id INTEGER PRIMARY KEY AUTOINCREMENT,
+#     reservation_id TEXT,
+#     table_id TEXT
+# );
+# """)
+
+# conn.commit()
+# conn.close()
+
+# print("Tables recreated successfully with AUTOINCREMENT ids.")
+
+import sqlite3
+
+conn = sqlite3.connect("restaurant_reservation.db")
+cursor = conn.cursor()
+
+try:
+    cursor.execute("""
+        UPDATE restaurants
+        SET name = 'Street Tacos Co'
+        WHERE name = 'Street Tacos Co.';
+    """)
+    conn.commit()
+    print("✅ Restaurant name updated successfully.")
+except Exception as e:
+    conn.rollback()
+    print(f"❌ Update failed: {e}")
+finally:
+    conn.close()
+

db/fill_details.py

@@ -0,0 +1,141 @@
+import uuid
+import random
+import sqlite3
+
+# ---------------------------
+# Data Classes
+# ---------------------------
+class Restaurant:
+    def __init__(self, restaurant_id, name, cuisine, location, seating_capacity, rating, address, contact, price_range, special_features):
+        self.restaurant_id = restaurant_id
+        self.name = name
+        self.cuisine = cuisine
+        self.location = location
+        self.seating_capacity = seating_capacity
+        self.rating = rating
+        self.address = address
+        self.contact = contact
+        self.price_range = price_range
+        self.special_features = special_features
+        self.tables = []
+
+class Table:
+    def __init__(self, table_id, restaurant_id, capacity=4):
+        self.table_id = table_id
+        self.restaurant_id = restaurant_id
+        self.capacity = capacity
+
+# ---------------------------
+# Sample Data
+# ---------------------------
+restaurant_names = [
+    "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"
+]
+
+locations = ['Downtown', 'Uptown', 'Midtown', 'Suburbs']
+special_features_list = ['Outdoor Seating', 'Pet-Friendly', 'Live Music', 'Rooftop View', 'Private Dining']
+
+def infer_cuisine(name):
+    name = name.lower()
+    if "italia" in name or "pasta" in name or "mama mia" in name:
+        return "Italian"
+    elif "tokyo" in name or "ramen" in name or "miso" in name:
+        return "Japanese"
+    elif "saffron" in name or "tandoori" in name or "curry" in name:
+        return "Indian"
+    elif "dumpling" in name or "noodle" in name:
+        return "Chinese"
+    elif "bistro" in name or "chez" in name or "marie" in name:
+        return "French"
+    elif "bangkok" in name:
+        return "Thai"
+    elif "el toro" in name or "tacos" in name:
+        return "Mexican"
+    elif "green" in name or "garden" in name:
+        return random.choice(["Multi-Cuisine", "Healthy", "Fusion"])
+    elif "skyline" in name or "ocean" in name:
+        return random.choice(["Multi-Cuisine", "Seafood", "Fusion"])
+    else:
+        return random.choice(["Italian", "Mexican", "Indian", "Japanese", "Chinese", "Thai", "French", "Multi-Cuisine"])
+
+# Create restaurant objects
+restaurants = []
+
+for i in range(20):
+    rest_id = str(uuid.uuid4())
+    name = restaurant_names[i]
+    cuisine = infer_cuisine(name)
+    if cuisine == "Multi-Cuisine":
+        cuisine = random.sample(["Italian", "Chinese", "Indian", "Mexican", "French"], k=2)
+
+    location = random.choice(locations)
+    num_tables = random.randint(10, 20)
+    seating_capacity = num_tables * 4
+    rating = round(random.uniform(3.5, 5.0), 1)
+    address = f"{100 + i} Main Street, {location}"
+    contact = f"555-{1000 + i}"
+    price_range = random.choice(['$', '$$', '$$$'])
+    features = random.sample(special_features_list, k=2)
+
+    restaurant = Restaurant(
+        restaurant_id=rest_id,
+        name=name,
+        cuisine=cuisine,
+        location=location,
+        seating_capacity=seating_capacity,
+        rating=rating,
+        address=address,
+        contact=contact,
+        price_range=price_range,
+        special_features=features
+    )
+
+    for _ in range(num_tables):
+        table_id = str(uuid.uuid4())
+        table = Table(table_id=table_id, restaurant_id=rest_id)
+        restaurant.tables.append(table)
+
+    restaurants.append(restaurant)
+
+# ---------------------------
+# Insert into SQLite Database
+# ---------------------------
+conn = sqlite3.connect("restaurant_reservation.db")
+cursor = conn.cursor()
+
+for r in restaurants:
+    cuisine_str = ", ".join(r.cuisine) if isinstance(r.cuisine, list) else r.cuisine
+    features_str = ", ".join(r.special_features)
+    
+    cursor.execute("""
+        INSERT INTO restaurants (id, name, cuisine, location, seating_capacity, rating, address, contact, price_range, special_features)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        r.restaurant_id,
+        r.name,
+        cuisine_str,
+        r.location,
+        r.seating_capacity,
+        r.rating,
+        r.address,
+        r.contact,
+        r.price_range,
+        features_str
+    ))
+
+    for t in r.tables:
+        cursor.execute("""
+            INSERT INTO tables (id, restaurant_id, capacity)
+            VALUES (?, ?, ?)
+        """, (
+            t.table_id,
+            t.restaurant_id,
+            t.capacity
+        ))
+
+conn.commit()
+conn.close()
+print("✅ Restaurants and tables successfully added to the database.")

db/print_db.py

@@ -0,0 +1,24 @@
+import sqlite3
+
+# Connect to the SQLite database
+conn = sqlite3.connect("restaurant_reservation.db")
+cursor = conn.cursor()
+
+# Function to print table contents
+def print_table_contents(table_name):
+    print(f"Contents of the {table_name} table:")
+    cursor.execute(f"SELECT * FROM {table_name}")
+    rows = cursor.fetchall()
+    for row in rows:
+        print(row)
+    print("\n")
+
+# Print contents of all the tables
+print_table_contents("restaurants")
+print_table_contents("tables")
+print_table_contents("slots")
+print_table_contents("reservations")
+print_table_contents("reservation_tables")
+
+# Close the database connection
+conn.close()

db/resetdb.py

@@ -0,0 +1,27 @@
+import sqlite3
+
+def reset_reservations():
+    sql_statements = [
+        "UPDATE slots SET is_reserved = 0;",
+        "DELETE FROM reservation_tables;",
+        "DELETE FROM reservations;"
+    ]
+
+    try:
+        conn = sqlite3.connect("restaurant_reservation.db")
+        cursor = conn.cursor()
+
+        cursor.execute("BEGIN TRANSACTION;")
+        for stmt in sql_statements:
+            cursor.execute(stmt)
+        conn.commit()
+        conn.close()
+        return "✅ All slots marked as reserved and reservations cleared."
+    except Exception as e:
+        conn.rollback()
+        conn.close()
+        return f"❌ Error during reset: {e}"
+
+# Call this function
+result = reset_reservations()
+print(result)

db/restaurant_reservation.db

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

prompts/determine_intent.txt

@@ -0,0 +1,21 @@
+You are an intent classification assistant for a restaurant reservation system.
+
+User input: "{user_input}"
+
+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

prompts/generate_reservation_conversation.txt

@@ -0,0 +1,30 @@
+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: "{user_query}"
+Always try to answer this user query.
+Current known user data (JSON): {user_data}
+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:  
+"{sql_summary}"  
+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: "{history_prompt_snippet}"  
+If earlier prompts asked for something now present in user data, don't ask again.
+
+Be helpful, efficient, and professional in tone.

prompts/interpret_sql_result.txt

@@ -0,0 +1,28 @@
+You are an expert assistant interpreting SQL query results for a restaurant reservation system.
+Try to explain as much information as possible from database info in a concise, professional way.
+Database schema overview:
+- restaurants(id, name, cuisine, location, seating_capacity, rating, address, contact, price_range [$, $$, $$$], special_features)
+- tables(id, restaurant_id, capacity=4)
+- slots(id, table_id, date, hour [9-21], is_reserved [0=free,1=reserved])
+
+Notes:
+- Each table seats 4 guests.
+- To accommodate a party, number_of_tables_needed = ceil(party_size / 4).
+- Slots represent table availability by hour.
+- The queries return counts or details based on user questions.
+
+You will get:
+- User question: {user_query}
+- Executed SQL query: {sql_query}
+Understand this sql clearly and properly.
+- Query result as JSON: {result_str}
+
+Instructions:
+- Provide a clear, professional summary of the query result in context of the user's question and the sql query.
+- For availability queries, explain if enough tables are free for the requested party size and time.
+- For list queries, list relevant restaurant details clearly.
+- If no data is found, say so politely.
+- Do not ask follow-up questions or add info not supported by the data.
+
+
+Now summarize the result based on the user query and data.

prompts/schema_prompt.txt

@@ -0,0 +1,50 @@
+You are an expert AI assistant for a restaurant reservation system using SQLite.  
+Your goal is to generate a single SELECT SQL query only.
+
+Use COUNT for availability checks to reduce result size, but when the query asks for restaurant info (name, rating, pricing, features), use regular SELECT without COUNT.
+
+SCHEMA
+- restaurants(id, name, cuisine, location, seating_capacity, rating, address, contact, price_range, special_features)
+- tables(id, restaurant_id, capacity = 4)
+- slots(id, table_id, date, hour, is_reserved = 0)
+strictly follow this schema
+
+LOGIC
+- Each table seats 4 → use CEIL(party_size / 4) to get number of tables needed.
+- Only consider slots where is_reserved = 0 and the date = '2025-05-12'.
+- JOIN order: slots → tables → restaurants
+- Use explicit column aliases to avoid ambiguity (e.g., s.id AS slot_id).
+- Never reference internal id fields in user-facing outputs.
+- Avoid SELECT * in multi-table joins.
+
+EXAMPLES
+1. Availability:
+SELECT COUNT(*) AS availability FROM slots WHERE is_reserved = 0 AND table_id IN (SELECT id FROM tables WHERE restaurant_id = (SELECT id FROM restaurants WHERE LOWER(name) = 'bella italia'));
+
+2. Availability at time:
+SELECT COUNT(*) AS available_tables FROM slots WHERE hour = 10 AND is_reserved = 0 AND table_id IN (SELECT id FROM tables WHERE restaurant_id = (SELECT id FROM restaurants WHERE LOWER(name) = 'bella italia'));
+
+3. Availability for party size:
+SELECT COUNT(*) AS available_tables FROM slots WHERE hour = 12 AND is_reserved = 0 AND table_id IN (SELECT id FROM tables WHERE restaurant_id = (SELECT id FROM restaurants WHERE LOWER(name) = 'bella italia'));
+→ compare count to CEIL(6 / 4) externally.
+
+4. Restaurant info:
+SELECT price_range FROM restaurants WHERE LOWER(name) = 'bella italia';
+5. Best restaurants:
+SELECT * FROM restaurants ORDER BY rating DESC
+5. Best restaurant with Mexican cuisine:
+SELECT * FROM restaurants WHERE cuisine LIKE '%Mexican%' ORDER BY rating DESC LIMIT 1;
+6. Which cuisine has the best rating? :
+SELECT cuisine, name AS restaurant_name, rating
+FROM restaurants
+ORDER BY rating DESC
+LIMIT 1;
+7. Total list:
+"Give me a list of restaurants"
+SELECT  FROM restaurants
+PRICING TERMS
+- "cheap" → $
+- "moderate" → $$
+- "expensive" → $$$
+
+History: {history_prompt}\n\nUser: {user_input}\nGive only SQL query as answer, SQL:

prompts/store_user_info.txt

@@ -0,0 +1,35 @@
+You are a helpful assistant. Extract relevant user information from this user statement:
+"{user_input}"
+
+Previously collected data in json: {previous_info}
+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