Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+menu_restorana.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: Menu Bot
-emoji: 📚
-colorFrom: indigo
-colorTo: green
+title: menu_bot
+app_file: menu.py
 sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
-pinned: false
+sdk_version: 5.49.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

menu.py

@@ -0,0 +1,234 @@
+from dotenv import load_dotenv
+from openai import OpenAI
+import json
+import os
+import requests
+from pathlib import Path
+from pypdf import PdfReader
+from pydantic import BaseModel
+import gradio as gr
+
+load_dotenv(override=True)
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_base_url = "https://api.pushover.net/1/messages.json"
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+
+
+class Evaluation(BaseModel):
+    is_acceptable: bool
+    feedback: str
+
+def push(text):
+    requests.post(
+        pushover_base_url,
+        data = {
+            "token": pushover_token,
+            "user": pushover_user,
+            "message": text
+        }
+    )
+
+def record_booking_table(email, name = "name not provided", date = "date not provided", time = "time not provided"):
+    push(f"{name} has booked tables on {date} at {time}. You can connect him via {email}")
+    return {"recorded": "ok"}
+
+def record_feedback(feedback):
+    push(f"Somebody has left feedback: {feedback}")
+    return {"recorded": "ok"}
+
+record_booking_table_json = {
+    "name" : "record_booking_table",
+    "description" : "Use this tool to record, when a user wants to book a table and provided his email.",
+    "parameters": {
+        "type": "object",
+        "properties":{
+            "email":{
+                "type": "string",
+                "description": "The email address of a user"
+            },
+            "name":{
+                "type": "string",
+                "description": "The user's name, if they provided it"
+            },
+            "date":{
+                "type": "string",
+                "description": "Date, when user wants to book a table like (xxth of month), if they provided it."
+            },
+            "time":{
+                "type": "string",
+                "description": "Time, when user wants to book a table like (hh:mm), if they provided it."
+            }
+        },
+        "required": ["email"],
+        "additionalProperties": False
+    }
+}
+
+record_feedback_json = {
+    "name": "record_feedback",
+    "description": "Always use this tool to record structured feedback about our restaurant. If feedback isn`t related to restaurant, don`t use this tool.",
+    "parameters":{
+        "type": "object",
+        "properties":{
+            "feedback": {
+                "type": "string",
+                "description": "The feedback that was given."
+            }
+        },
+        "required": ["feedback"],
+        "additionalProperties": False
+    }
+}
+
+tools = [{"type": "function", "function": record_booking_table_json},
+        {"type": "function", "function": record_feedback_json}]
+
+
+class RestaurantBot:
+    def __init__(self):
+        self.gemini = OpenAI(base_url = GEMINI_BASE_URL, api_key=gemini_api_key)
+        self.name = "Night City"
+        pdf_path = Path(__file__).resolve().parent / "menu_restorana.pdf"
+        reader = PdfReader(str(pdf_path))
+        self.menu = ""
+        for page in reader.pages:
+            text = page.extract_text()
+            if text:
+                self.menu += text
+
+    def handle_tool_call(self, tool_calls):
+        results =[]
+        for tool_call in tool_calls:
+            tool_name = tool_call.function.name
+            arguments = json.loads(tool_call.function.arguments)
+            tool = globals().get(tool_name)
+            result = tool(**arguments) if tool else {}
+            results.append({"role": "tool", "content": json.dumps(result), "tool_call_id": tool_call.id})
+        return results
+
+    def system_prompt(self):
+            system_instructions = f"""
+            You are Alexander, the professional and welcoming head hostess of the '{self.name}' restaurant. 
+            Your primary goal is to assist guests with the menu, answer questions about dishes, and facilitate table reservations.
+
+            ### OPERATIONAL DETAILS:
+            * **Working Hours**: We are open from 10:00 to 22:00 every day.
+            * **Contact Numbers**: (097) 454 6555 or (063) 584 65 55.
+            * **Official Website**: night-city.com.ua[cite: 7, 11].
+
+            ### GUIDELINES:
+            1. **Persona**: Be polite, sophisticated, and helpful. Treat every user as a valued guest entering our establishment.
+            2. **Menu Knowledge**: Use the provided menu context to describe dishes, ingredients, and prices.
+            3. **Upselling**: When a guest shows interest in meat or fish dishes, suggest a matching wine from our Georgian or French collections.
+            4. **Reservations**: 
+            - Actively encourage guests to book a table if they seem interested in visiting.
+            - You MUST obtain an **email address** to complete a booking.
+            - Try to collect the guest's name, preferred date, and time.
+            - Once you have the email, use the `record_booking_table` tool immediately.
+            5. **Feedback & Edge Cases**:
+            - If a guest wants to leave a review, complaint, or suggestion, use the `record_feedback` tool.
+            - If you are asked a question you cannot answer based on the menu, or if the request is unrelated to the restaurant, politely inform the guest that you will pass this to the manager and use the `record_feedback` tool to log it.
+
+            ### RESTAURANT MENU:
+            {self.menu}
+
+            Act as Alexander. Always stay in character and respond in the language used by the guest.
+            """
+            return system_instructions
+
+    def evaluator_system_prompt(self):
+        # Follow the evaluation pattern from 3_lab3.ipynb, adapted to the restaurant persona
+        system = (
+            "You are an evaluator that decides whether a response to a restaurant guest is acceptable.\n"
+            "You are provided with a conversation between a Guest and Alexander (the restaurant host).\n"
+            "Your task is to decide whether Alexander's latest response is acceptable quality.\n"
+            "Alexander must be polite, professional, knowledgeable about the menu, and helpful with reservations.\n"
+            "Alexander has been given detailed instructions and the full restaurant menu as context:\n\n"
+            f"{self.system_prompt()}\n\n"
+            "With this context, please evaluate the latest response, replying with whether the response is acceptable and your feedback."
+        )
+        return system
+
+    def evaluator_user_prompt(self, reply, message, history):
+        user_prompt = f"Here's the conversation between the Guest and Alexander: \n\n{history}\n\n"
+        user_prompt += f"Here's the latest message from the Guest: \n\n{message}\n\n"
+        user_prompt += f"Here's the latest response from Alexander: \n\n{reply}\n\n"
+        user_prompt += "Please evaluate the response, replying with whether it is acceptable and your feedback."
+        return user_prompt
+
+    def evaluate(self, reply, message, history) -> Evaluation:
+        messages = [
+            {"role": "system", "content": self.evaluator_system_prompt()},
+            {"role": "user", "content": self.evaluator_user_prompt(reply, message, history)},
+        ]
+        response = self.gemini.beta.chat.completions.parse(
+            model="gemini-2.5-flash", messages=messages, response_format=Evaluation
+        )
+        return response.choices[0].message.parsed
+
+    def rerun(self, reply, message, history, feedback):
+        # Same rerun pattern as in 3_lab3.ipynb: augment system prompt with rejection info
+        updated_system_prompt = self.system_prompt() + "\n\n## Previous answer rejected\n"
+        updated_system_prompt += "You just tried to reply, but the quality control rejected your reply.\n"
+        updated_system_prompt += f"## Your attempted answer:\n{reply}\n\n"
+        updated_system_prompt += f"## Reason for rejection:\n{feedback}\n\n"
+        messages = [{"role": "system", "content": updated_system_prompt}] + history + [
+            {"role": "user", "content": message}
+        ]
+        response = self.gemini.chat.completions.create(
+            model="gemini-2.5-flash", messages=messages, tools=tools
+        )
+        return response.choices[0].message.content
+
+    def chat(self, message, history):
+        # Clean history like in the lab note so providers don't choke on extra keys
+        history = [{"role": h["role"], "content": h["content"]} for h in history]
+
+        messages = [{"role": "system", "content": self.system_prompt()}] + history + [
+            {"role": "user", "content": message}
+        ]
+        done = False
+        response = None
+        while not done:
+            response = self.gemini.chat.completions.create(
+                model="gemini-2.5-flash", messages=messages, tools=tools
+            )
+            if response.choices[0].finish_reason == "tool_calls":
+                msg_obj = response.choices[0].message
+                tool_calls = msg_obj.tool_calls
+                results = self.handle_tool_call(tool_calls)
+                # Store a plain-dict version of the assistant message
+                if hasattr(msg_obj, "model_dump"):
+                    messages.append(msg_obj.model_dump())
+                elif hasattr(msg_obj, "to_dict"):
+                    messages.append(msg_obj.to_dict())
+                else:
+                    messages.append(
+                        {
+                            "role": "assistant",
+                            "content": getattr(msg_obj, "content", None),
+                            "tool_calls": tool_calls,
+                        }
+                    )
+                messages.extend(results)
+            else:
+                done = True
+
+        reply = response.choices[0].message.content
+
+        # Run evaluation just like in 3_lab3.ipynb
+        evaluation = self.evaluate(reply, message, history)
+        if evaluation.is_acceptable:
+            print("Passed evaluation - returning reply")
+            return reply
+        else:
+            print("Failed evaluation - retrying")
+            print(evaluation.feedback)
+            return self.rerun(reply, message, history, evaluation.feedback)
+
+
+if __name__ == "__main__":
+    restaurant_bot = RestaurantBot()
+    gr.ChatInterface(restaurant_bot.chat, type="messages").launch()

menu_restorana.pdf

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