Rename app.py to app_streamlit.py

app.py

@@ -1,89 +0,0 @@
-import torch
-from transformers import AutoTokenizer, pipeline
-from sentence_transformers import SentenceTransformer
-import faiss
-import numpy as np
-import gradio as gr
-from typing import List
-
-# Configuration
-class Config:
-    model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
-    embedding_model = "all-MiniLM-L6-v2"
-    vector_dim = 384  # Sentence Transformer embedding dimension
-    top_k = 3  # Retrieve top 3 relevant chunks
-    chunk_size = 256  # Text chunk size
-
-# Vector Database
-class VectorDB:
-    def __init__(self):
-        self.index = faiss.IndexFlatL2(Config.vector_dim)
-        self.texts = []
-        self.embedding_model = SentenceTransformer(Config.embedding_model)
-    
-    def add_text(self, text: str):
-        embedding = self.embedding_model.encode([text])[0]
-        embedding = np.array([embedding], dtype=np.float32)
-        faiss.normalize_L2(embedding)
-        self.index.add(embedding)
-        self.texts.append(text)
-    
-    def search(self, query: str) -> List[str]:
-        if self.index.ntotal == 0:
-            return []
-        query_embedding = self.embedding_model.encode([query])[0]
-        query_embedding = np.array([query_embedding], dtype=np.float32)
-        faiss.normalize_L2(query_embedding)
-        D, I = self.index.search(query_embedding, min(Config.top_k, self.index.ntotal))
-        return [self.texts[i] for i in I[0] if i < len(self.texts)]
-
-# Load Model
-class TinyChatModel:
-    def __init__(self):
-        self.tokenizer = AutoTokenizer.from_pretrained(Config.model_name)
-        self.pipe = pipeline("text-generation", model=Config.model_name, torch_dtype=torch.bfloat16, device_map="auto")
-
-    def generate_response(self, message: str, context: str = "") -> str:
-        messages = [{"role": "user", "content": message}]
-        if context:
-            messages.insert(0, {"role": "system", "content": f"Context:\n{context}"})
-        prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        outputs = self.pipe(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
-        return outputs[0]["generated_text"].split("<|assistant|>")[-1].strip()
-
-# Initialize
-vector_db = VectorDB()
-chat_model = TinyChatModel()
-
-# Function to handle context addition and chat
-def chat_function(user_input: str, context: str = ""):
-    if context:
-        vector_db.add_text(context)
-    
-    # Search relevant context
-    context_text = "\n".join(vector_db.search(user_input))
-    response = chat_model.generate_response(user_input, context_text)
-    vector_db.add_text(f"User: {user_input}\nAssistant: {response}")
-    
-    return response
-
-# Gradio Interface
-def gradio_interface(user_input: str, context: str = ""):
-    response = chat_function(user_input, context)
-    return response
-
-# Create Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("# TinyChat: A Conversational AI")
-    with gr.Row():
-        with gr.Column():
-            user_input = gr.Textbox(label="User Input", placeholder="Ask anything...")
-            context_input = gr.Textbox(label="Optional Context", placeholder="Paste context here (optional)", lines=3)
-            submit_button = gr.Button("Send")
-            output = gr.Textbox(label="Response", placeholder="Assistant's reply will appear here...")
-            
-            submit_button.click(fn=gradio_interface, inputs=[user_input, context_input], outputs=output)
-
-# Run the Gradio app
-if __name__ == "__main__":
-    demo.launch(share=True)

app_streamlit.py

@@ -0,0 +1,583 @@
+import streamlit as st
+import pandas as pd
+import json
+from openai import OpenAI
+import os
+import uuid
+import time
+
+# Sample data - you'll need to create data.py or embed this data
+restaurants_data = [
+    {"id": "r001", "name": "Spice Garden", "locality": "Downtown", "cuisine": "Indian", "price_range": "800-1200"},
+    {"id": "r002", "name": "Pizza Palace", "locality": "Mall Road", "cuisine": "Italian", "price_range": "400-800"},
+    {"id": "r003", "name": "Dragon House", "locality": "City Center", "cuisine": "Chinese", "price_range": "600-1000"},
+    {"id": "r004", "name": "Burger Junction", "locality": "Food Street", "cuisine": "American", "price_range": "300-600"},
+    {"id": "r005", "name": "Sushi Bar", "locality": "Downtown", "cuisine": "Japanese", "price_range": "1000-1500"},
+]
+
+reservation_data = [
+    {"reservation_id": 31005202500001, "restaurant_id": "r001", "user_name": "John Doe", "party_size": 4, "date": "2025-06-15", "time": "19:00", "special_requests": "", "status": "Confirmed"},
+]
+
+# Streamlit UI setup
+st.set_page_config(page_title="foodieSpot", layout="centered")
+
+class BookingState:
+    def __init__(self):
+        self.data = {
+            "reservation_id": None,
+            "state": None,
+            "cuisine_preference": None,
+            "location": None,
+            "date": None,
+            "time": None,
+            "party_size": None,
+            "special_requests": None,
+            "restaurant_id": None,
+            "user_name": None
+        }
+
+    def update(self, **kwargs):
+        for key, value in kwargs.items():
+            if key in self.data:
+                self.data[key] = value
+            else:
+                raise KeyError(f"Invalid key: '{key}' not in booking data.")
+        return self.check_state()
+
+    def check_state(self):
+        return {k: v for k, v in self.data.items() if v is not None}
+
+    def is_complete(self):
+        required = [
+            "cuisine_preference", "location", "date", "time", "party_size",
+            "restaurant_id", "user_name"
+        ]
+        return all(self.data.get(k) is not None for k in required)
+
+    def reset(self):
+        for key in self.data:
+            self.data[key] = None
+
+    def to_dict(self):
+        return self.data.copy()
+
+class ReservationManager:
+    def __init__(self, restaurants_df, reservation_df):
+        self.restaurants_df = restaurants_df
+        self.reservations_df = reservation_df
+        self.reservation_counter = 31005202500001
+
+    def _generate_reservation_id(self):
+        self.reservation_counter += 1
+        return self.reservation_counter
+
+    def is_valid_booking(self, booking_state):
+        required = ["restaurant_id", "user_name", "party_size", "date", "time"]
+        return all(booking_state.data.get(k) for k in required)
+
+    def add_reservation(self, booking_state):
+        if not self.is_valid_booking(booking_state):
+            missing = [
+                k for k in
+                ["restaurant_id", "user_name", "party_size", "date", "time"]
+                if booking_state.data.get(k) is None
+            ]
+            return {
+                "success": False,
+                "message": "Reservation could not be created. Missing fields.",
+                "missing_fields": missing
+            }
+
+        reservation_id = self._generate_reservation_id()
+
+        reservation = {
+            "reservation_id": reservation_id,
+            "restaurant_id": booking_state.data["restaurant_id"],
+            "user_name": booking_state.data["user_name"],
+            "party_size": booking_state.data["party_size"],
+            "date": booking_state.data["date"],
+            "time": booking_state.data["time"],
+            "special_requests": booking_state.data.get("special_requests", ""),
+            "status": "Confirmed"
+        }
+
+        # Add to DataFrame
+        new_row = pd.DataFrame([reservation])
+        self.reservations_df = pd.concat([self.reservations_df, new_row], ignore_index=True)
+
+        return {
+            "success": True,
+            "message": "Reservation confirmed!",
+            "reservation_details": reservation
+        }
+
+    def get_all_reservations(self):
+        return self.reservations_df.to_dict(orient="records")
+
+class RestaurantQueryEngine:
+    def __init__(self, df):
+        self.df = df
+
+    def get_options(self, column_name):
+        if column_name in self.df.columns:
+            return sorted(self.df[column_name].dropna().unique().tolist())
+        return []
+
+    def filter_by(self, column_name, value):
+        result = self.df.copy()
+        if column_name in result.columns and value is not None:
+            result = result[result[column_name] == value]
+        return result[["id", "name", "locality", "cuisine", "price_range"]].to_dict(orient="records")
+
+# Initialize OpenAI client
+@st.cache_resource
+def get_openai_client():
+    api_key = os.environ.get('OPENAI_API_KEY')
+    if not api_key:
+        st.error("❌ OPENAI_API_KEY environment variable is required")
+        st.info("Please set your OpenAI API key in the Hugging Face Spaces settings")
+        st.stop()
+    return OpenAI(api_key=api_key)
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "session_id" not in st.session_state:
+    st.session_state.session_id = str(uuid.uuid4())
+
+if "page" not in st.session_state:
+    st.session_state.page = "chat"
+
+if "booking_state" not in st.session_state:
+    st.session_state.booking_state = BookingState()
+
+if "reservation_manager" not in st.session_state:
+    restaurants_df = pd.DataFrame(restaurants_data)
+    reservations_df = pd.DataFrame(reservation_data)
+    st.session_state.reservation_manager = ReservationManager(restaurants_df, reservations_df)
+
+if "query_engine" not in st.session_state:
+    restaurants_df = pd.DataFrame(restaurants_data)
+    st.session_state.query_engine = RestaurantQueryEngine(restaurants_df)
+
+if "conversation_history" not in st.session_state:
+    st.session_state.conversation_history = []
+
+# Tools definition
+tools = [{
+    "type": "function",
+    "function": {
+        "name": "get_column_options",
+        "description": "Get unique available values for a column like cuisine, locality, or price_range.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "column_name": {
+                    "type": "string",
+                    "description": "The column to get unique values from. Common options: 'cuisine', 'locality', 'price_range'."
+                }
+            },
+            "required": ["column_name"]
+        }
+    }
+}, {
+    "type": "function",
+    "function": {
+        "name": "filter_restaurants",
+        "description": "Filter the list of restaurants based on a specific attribute like cuisine, location, or price range.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "column_name": {
+                    "type": "string",
+                    "description": "The column to filter by. Common values: 'cuisine', 'locality', 'price_range'."
+                },
+                "value": {
+                    "type": "string",
+                    "description": "The value to match in the specified column."
+                }
+            },
+            "required": ["column_name", "value"]
+        }
+    }
+}, {
+    "type": "function",
+    "function": {
+        "name": "update_booking_state",
+        "description": "Update the booking information with user's reservation details.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "cuisine_preference": {"type": "string"},
+                "location": {"type": "string"},
+                "date": {"type": "string", "description": "Date of reservation in YYYY-MM-DD format."},
+                "time": {"type": "string", "description": "Time of reservation in HH:MM format."},
+                "party_size": {"type": "integer"},
+                "special_requests": {"type": "string"},
+                "restaurant_id": {"type": "string"},
+                "user_name": {"type": "string"}
+            },
+            "required": []
+        }
+    }
+}, {
+    "type": "function",
+    "function": {
+        "name": "finalize_booking",
+        "description": "Check if all necessary booking information is filled. If complete, return all data.",
+        "parameters": {
+            "type": "object",
+            "properties": {}
+        }
+    }
+}, {
+    "type": "function",
+    "function": {
+        "name": "make_reservation",
+        "description": "Create a confirmed reservation using current booking state and return reservation ID and details.",
+        "parameters": {
+            "type": "object",
+            "properties": {}
+        }
+    }
+}]
+
+SYSTEM_PROMPT = """
+You are a friendly and efficient restaurant reservation assistant.
+
+Your role is to help users find and reserve a restaurant based on their preferences like cuisine, location, date, time, and party size. If needed, collect this information in a polite and conversational way.
+
+Recommendation and suggestion:
+- ask user politely what they want the suggestions to be based on, location, cuisine, or price_range.
+- when the user gives the value for a suggestion, then show him available restaurants for that value.
+- **DO NOT SHOW MORE THAN 4 OPTIONS AT A TIME**
+
+Information Collection:
+- Reservation Details needed to complete a booking: [cuisine_preference, location, date, time, party_size, special_requests, restaurant_id, user_name]
+- **ASK FOR ONE DETAIL ONLY AT A TIME**
+
+Once all information is gathered, confirm the booking by calling the `make_reservation` tool. Be proactive in guiding the user. Do not hallucinate values. Rely on tools to fetch available options or complete bookings.
+
+Always be warm and polite, like a concierge at a high-end restaurant. Use natural and welcoming phrases like:
+- "Great! Let me note that down."
+- "Could you please tell me…?"
+- "Absolutely, I can help with that."
+"""
+
+def call_tool(tool_name, args):
+    """Direct function calls instead of Flask endpoints"""
+    if tool_name == "get_column_options":
+        return st.session_state.query_engine.get_options(**args)
+    elif tool_name == "update_booking_state":
+        return st.session_state.booking_state.update(**args)
+    elif tool_name == "make_reservation":
+        result = st.session_state.reservation_manager.add_reservation(
+            st.session_state.booking_state
+        )
+        if result['success']:
+            st.session_state.booking_state.reset()
+        return result
+    elif tool_name == "filter_restaurants":
+        return st.session_state.query_engine.filter_by(**args)
+    elif tool_name == "finalize_booking":
+        return st.session_state.booking_state.check_state()
+    else:
+        return {"error": f"Unknown tool: {tool_name}"}
+
+def process_chat_message(message):
+    """Process chat message with OpenAI - replaces Flask /chat endpoint"""
+    client = get_openai_client()
+    
+    st.session_state.conversation_history.append({
+        "role": "user",
+        "content": message
+    })
+
+    messages = [{
+        "role": "system",
+        "content": SYSTEM_PROMPT
+    }] + st.session_state.conversation_history
+
+    continue_processing = True
+    final_response = ""
+
+    while continue_processing:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            tools=tools,
+            tool_choice="auto"
+        )
+
+        message_obj = response.choices[0].message
+
+        if message_obj.content:
+            final_response = message_obj.content
+            st.session_state.conversation_history.append({
+                "role": "assistant",
+                "content": message_obj.content
+            })
+            continue_processing = False
+
+        if message_obj.tool_calls:
+            st.session_state.conversation_history.append({
+                "role": "assistant",
+                "content": "",
+                "tool_calls": message_obj.tool_calls
+            })
+
+            for tool_call in message_obj.tool_calls:
+                tool_name = tool_call.function.name
+                tool_args = json.loads(tool_call.function.arguments)
+                tool_output = call_tool(tool_name, tool_args)
+
+                st.session_state.conversation_history.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "name": tool_name,
+                    "content": json.dumps(tool_output)
+                })
+
+            messages = [{
+                "role": "system",
+                "content": SYSTEM_PROMPT
+            }] + st.session_state.conversation_history
+
+            continue_processing = True
+
+    return final_response
+
+# Custom CSS
+st.markdown("""
+<style>
+.backend-button {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    z-index: 999;
+    background: linear-gradient(45deg, #ff6b9d, #ff8a9b);
+    color: white;
+    padding: 10px 20px;
+    border: none;
+    border-radius: 25px;
+    font-weight: bold;
+    cursor: pointer;
+    box-shadow: 0 4px 12px rgba(255, 107, 157, 0.3);
+    transition: all 0.3s ease;
+}
+.backend-button:hover {
+    background: linear-gradient(45deg, #ff5588, #ff7799);
+    transform: translateY(-2px);
+    box-shadow: 0 6px 16px rgba(255, 107, 157, 0.4);
+}
+
+.restaurant-tile {
+    background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+    border-radius: 15px;
+    padding: 15px;
+    margin: 10px 0;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    border-left: 4px solid #ff6b9d;
+    transition: all 0.3s ease;
+}
+
+.restaurant-tile:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.restaurant-name {
+    font-weight: bold;
+    color: #333;
+    font-size: 16px;
+    margin-bottom: 8px;
+}
+
+.restaurant-detail {
+    color: #666;
+    font-size: 14px;
+    margin: 4px 0;
+}
+
+.restaurant-price {
+    color: #ff6b9d;
+    font-weight: bold;
+    font-size: 14px;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# Top navigation
+col1, col2 = st.columns([6, 1])
+with col2:
+    if st.button("🔧 Backend", key="backend_btn", help="View reservations dashboard"):
+        st.session_state.page = "backend"
+        st.rerun()
+
+def show_chat_page():
+    st.title("💬 foodieSpot")
+    st.markdown("Restaurant Reservations made easy!")
+    
+    # System ready indicator
+    st.success("✅ System ready")
+
+    # Display chat history
+    for msg in st.session_state.messages:
+        with st.chat_message(msg["role"]):
+            st.markdown(msg["content"])
+
+    # Input and send button
+    user_input = st.chat_input("Type your message...")
+
+    if user_input:
+        # Handle exit command
+        if user_input.lower() in ['exit', 'quit', 'bye']:
+            bot_reply = 'Thanks for using foodieSpot! Have a great day! 🍽️'
+
+            # Save messages
+            st.session_state.messages.append({"role": "user", "content": user_input})
+            st.session_state.messages.append({"role": "assistant", "content": bot_reply})
+
+            # Display messages
+            with st.chat_message("user"):
+                st.markdown(user_input)
+            with st.chat_message("assistant"):
+                st.markdown(bot_reply)
+
+            st.stop()
+
+        # Save user message
+        st.session_state.messages.append({"role": "user", "content": user_input})
+        with st.chat_message("user"):
+            st.markdown(user_input)
+
+        # Show typing indicator
+        with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            message_placeholder.markdown("🤔 Thinking...")
+
+            try:
+                # Direct function call instead of HTTP request
+                bot_reply = process_chat_message(user_input)
+            except Exception as e:
+                bot_reply = f"❌ An error occurred: {str(e)}"
+
+            # Update the message placeholder with the actual response
+            message_placeholder.markdown(bot_reply)
+
+        # Save bot message
+        st.session_state.messages.append({"role": "assistant", "content": bot_reply})
+
+    # Sidebar with additional info
+    with st.sidebar:
+        st.header("ℹ️ App Info")
+        st.write("**Session ID:**", st.session_state.session_id[:8] + "...")
+        st.write("**Messages:**", len(st.session_state.messages))
+
+        if st.button("🔄 New Session"):
+            st.session_state.messages = []
+            st.session_state.conversation_history = []
+            st.session_state.booking_state.reset()
+            st.session_state.session_id = str(uuid.uuid4())
+            st.rerun()
+
+        if st.button("🧹 Clear Chat"):
+            st.session_state.messages = []
+            st.session_state.conversation_history = []
+            st.rerun()
+
+        st.header("🍽️ Available Restaurants")
+        restaurants = restaurants_data
+        for restaurant in restaurants[:8]:  # Show only first 8 restaurants
+            restaurant_tile = f"""
+            <div class="restaurant-tile">
+                <div class="restaurant-name">{restaurant['name']}</div>
+                <div class="restaurant-detail">🍜 {restaurant['cuisine']}</div>
+                <div class="restaurant-detail">📍 {restaurant['locality']}</div>
+                <div class="restaurant-price">💰 ₹{restaurant['price_range']}</div>
+            </div>
+            """
+            st.markdown(restaurant_tile, unsafe_allow_html=True)
+            
+        if len(restaurants) > 8:
+            st.markdown(f"<div style='text-align: center; color: #666; font-style: italic; margin-top: 10px;'>...and {len(restaurants) - 8} more restaurants</div>", unsafe_allow_html=True)
+
+        st.header("💡 Tips")
+        st.write("Try asking:")
+        st.write("- 'Show me Chinese restaurants'")
+        st.write("- 'I want to book a table'")
+        st.write("- 'What cuisines are available?'")
+        st.write("- 'Book for 4 people tomorrow at 7 PM'")
+
+def show_backend_page():
+    st.title("🔧 Backend Dashboard")
+    st.markdown("Real-time view of restaurant reservations")
+    
+    if st.button("← Back to Chat"):
+        st.session_state.page = "chat"
+        st.rerun()
+    
+    if "last_refresh" not in st.session_state:
+        st.session_state.last_refresh = time.time()
+    
+    # Auto-refresh every 5 seconds
+    current_time = time.time()
+    if current_time - st.session_state.last_refresh > 5:
+        st.session_state.last_refresh = current_time
+        st.rerun()
+    
+    st.markdown(f"🔄 Auto-refreshing every 5 seconds | Last updated: {time.strftime('%H:%M:%S')}")
+    
+    try:
+        # Get reservations data directly from session state
+        reservations_data_list = st.session_state.reservation_manager.get_all_reservations()
+        
+        if reservations_data_list:
+            # Convert to DataFrame for better display
+            df = pd.DataFrame(reservations_data_list)
+            
+            st.subheader(f"📊 Total Reservations: {len(df)}")
+            
+            # Display metrics
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total Reservations", len(df))
+            with col2:
+                if 'status' in df.columns:
+                    confirmed = len(df[df['status'] == 'Confirmed'])
+                    st.metric("Confirmed", confirmed)
+            with col3:
+                if 'party_size' in df.columns:
+                    total_guests = df['party_size'].sum()
+                    st.metric("Total Guests", total_guests)
+            
+            # Display the table
+            st.subheader("📋 Reservations Table")
+            st.dataframe(
+                df,
+                use_container_width=True,
+                hide_index=True
+            )
+            
+            # Download button
+            csv = df.to_csv(index=False)
+            st.download_button(
+                label="📥 Download CSV",
+                data=csv,
+                file_name=f"reservations_{time.strftime('%Y%m%d_%H%M%S')}.csv",
+                mime="text/csv"
+            )
+            
+        else:
+            st.info("📭 No reservations found")
+            
+    except Exception as e:
+        st.error(f"❌ Error fetching data: {str(e)}")
+
+# Main app logic
+if st.session_state.page == "chat":
+    show_chat_page()
+elif st.session_state.page == "backend":
+    show_backend_page()