Upload 2 files

app.py

@@ -4,6 +4,9 @@ import gradio as gr
 import uuid
 from pprint import pprint
 import chromadb
+import json
+import requests
+import random
 
 #-----------------------
 # Setup
@@ -226,6 +229,99 @@ collection.add(
 
 pprint(collection.get())
 
+#-----------------------
+# Tools
+#-----------------------
+tools = []
+
+#### 1. Import pushover keys
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_url = "https://api.pushover.net/1/messages.json"  # Pushover API endpoint for sending messages
+# Create send_notification function to send a notification using Pushover API
+#create a function to send a notification using Pushover API
+def send_notification(message:str):
+    payload = {"user": pushover_user, "token": pushover_token, "message": message}
+    requests.post(pushover_url, data=payload)
+
+### 3. Describe Pushover as an LLM tool
+#creating a function to explain LLM when to use the tool and how to call it, including the expected input and output formats. This will help the LLM understand how to use the tool effectively and provide the necessary information for successful execution.
+send_notification_function = {
+    #creating dictionary 
+    "name": "send_notification",
+    "description": "Sends a push notification to the real-world version of you using Pushover on mobile. Use this if the user needs to alert the real-world version of you.",
+    "parameters": {
+        # way LLM should format the input when calling the function / JSON theobject with key-value pairs corresponding to the function's parameters
+        "type": "object", 
+        "properties": {
+            "message": {
+                "type": "string",
+                "description": "The content of the notification message to be sent to the user's device."
+            }
+        },
+        "required": ["message"]
+    }
+}
+### 3. Add Pushover to the list of tools for the LLM
+# This is the list of tools that the LLM can use to interact with the environment. Each tool is defined by a dictionary that includes its name, description, and parameters. The LLM will use this information to determine when and how to call the tool during the conversation.
+# we have just one tool in our list, but we could add more tools in the future by appending additional dictionaries to this list.
+tools.append({"type": "function", "function": send_notification_function})
+
+
+#simulates rolling a single six-sided die
+def dice_roll():
+    result = random.randint(1,6)
+    return result 
+
+#describe function for LLM
+#dice role functionality 
+roll_dice_function = {
+    "name": "dice_roll",
+    "description": "Simulates rolling a single six-sided die and returns the result. Use this when the user wants to roll a die for games, decisions or random number generation",
+    "parameters": {
+        # way LLM should format the input when calling the function / JSON theobject with key-value pairs corresponding to the function's parameters
+        "type": "object", 
+        "properties": {},
+        "required": []
+    }
+}
+
+#Add function to list of tools of LLM
+tools.append({"type": "function", "function": roll_dice_function})
+
+
+#-----------------------
+# Tool Call Handler 
+#-----------------------
+def handle_tool_call(tool_calls):
+    tool_results = []
+
+    for tool_call in tool_calls:   
+        function_name = tool_call.function.name  
+        args = json.loads(tool_call.function.arguments)
+        #print(f"Calling funvtion {function_name}")  #for future debugging 
+        #Route to the appropriate function based on function name
+        if function_name == "send_notification":
+            #acctually send the notification, i.e. call the tool
+            send_notification(args["message"])
+            content = f"Notification sent: {args['message']}"
+        elif function_name == "dice_roll":
+            content = f"Rolled: {dice_roll()}"
+        #elif function_name == "insert_function_name_3":
+        #   content = insert_function_name_3(args["message"])
+        else:
+            content = f"Uknown function: {function_name}"
+        #print(f"Sent notification with message: {args['message']}")
+        tool_call_result = {
+            "role": "tool", 
+            "content": content,
+            "tool_call_id" : tool_call.id
+        }
+        tool_results.append(tool_call_result)
+    #return what to add to our "context (about tool call results), a dictionary "
+    return tool_results
+
+
 #-----------------------
 # System Message 
 #-----------------------
@@ -274,10 +370,30 @@ def respond_ai(message, history):
    #Call LLM
    response = client.chat.completions.create(
       model="gpt-4.1-mini",
-      messages=messages
+      messages=messages,
+      tools=tools
     )
    
    message = response.choices[0].message
+
+   #check if model wants to call a tool
+   while message.tool_calls:
+        pprint(message.tool_calls)
+        #..handle tool call
+        tool_result = handle_tool_call(message.tool_calls)  #whole list of tool calls on purpose
+         #..add message to "context", i.e. messages 
+        messages.append(message)
+        #..add information about the tool call to the context for the LLM to learn from i.e. messages 
+        messages.extend(tool_result) #cheanged from append() to extend() when we switched to multiple tool call handling
+
+        # ..invoke the LLM one more time to get it's updated response and provide context with tool calling
+        response = client.chat.completions.create(
+             model="gpt-4.1-mini",
+             messages=messages,
+             tools=tools # consecutive tool call will be considered by LLM
+    )
+        message = response.choices[0].message
+             
    return(message.content)
 
 #-----------------------

requirements.txt

@@ -1,3 +1,4 @@
 openai
 gradio
 chromadb
+requests