update tool handler

.gitignore

@@ -1,2 +1,4 @@
 .venv/
-.env
+.env
+__pycache__/config.cpython-310.pyc
+__pycache__/tool_handler.cpython-310.pyc

app.py

@@ -1,10 +1,9 @@
 import gradio as gr
 import anthropic
 import json
-import requests
-import warnings
 import logging
-import os
+from tool_handler import process_tool_call, tools
+from config import SYSTEM_PROMPT, API_KEY, MODEL_NAME
 from datasets import load_dataset
 import pandas as pd
 from dotenv import load_dotenv
@@ -17,154 +16,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger(__name__)
 
 # Initialize Anthropoc client with API key
-client = anthropic.Client(api_key=os.getenv('ANTHROPIC_API_KEY'))
-MODEL_NAME = "claude-3-5-sonnet-20240620"
-
-# Define the base URL for the FastAPI service
-BASE_URL = "https://dwb2023-blackbird-svc.hf.space"
-
-# Define tools
-tools = [
-    {
-        "name": "get_user",
-        "description": "Looks up a user by email, phone, or username.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "key": {
-                    "type": "string",
-                    "enum": ["email", "phone", "username"],
-                    "description": "The attribute to search for a user by (email, phone, or username)."
-                },
-                "value": {
-                    "type": "string",
-                    "description": "The value to match for the specified attribute."
-                }
-            },
-            "required": ["key", "value"]
-        }
-    },
-    {
-        "name": "get_order_by_id",
-        "description": "Retrieves the details of a specific order based on the order ID.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "order_id": {
-                    "type": "string",
-                    "description": "The unique identifier for the order."
-                }
-            },
-            "required": ["order_id"]
-        }
-    },
-    {
-        "name": "get_customer_orders",
-        "description": "Retrieves the list of orders belonging to a user based on a user's customer id.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "customer_id": {
-                    "type": "string",
-                    "description": "The customer_id belonging to the user"
-                }
-            },
-            "required": ["customer_id"]
-        }
-    },
-    {
-        "name": "cancel_order",
-        "description": "Cancels an order based on a provided order_id. Only orders that are 'processing' can be cancelled.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "order_id": {
-                    "type": "string",
-                    "description": "The order_id pertaining to a particular order"
-                }
-            },
-            "required": ["order_id"]
-        }
-    },
-    {
-        "name": "update_user_contact",
-        "description": "Updates a user's email and/or phone number.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "user_id": {
-                    "type": "string",
-                    "description": "The ID of the user"
-                },
-                "email": {
-                    "type": "string",
-                    "description": "The new email address of the user"
-                },
-                "phone": {
-                    "type": "string",
-                    "description": "The new phone number of the user"
-                }
-            },
-            "required": ["user_id"]
-        }
-    },
-    {
-        "name": "get_user_info",
-        "description": "Retrieves a user's information along with their order history based on email, phone, or username.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "key": {
-                    "type": "string",
-                    "enum": ["email", "phone", "username"],
-                    "description": "The attribute to search for a user by (email, phone, or username)."
-                },
-                "value": {
-                    "type": "string",
-                    "description": "The value to match for the specified attribute."
-                }
-            },
-            "required": ["key", "value"]
-        }
-    }
-]
-
-# Suppress the InsecureRequestWarning
-warnings.filterwarnings("ignore", category=requests.urllib3.exceptions.InsecureRequestWarning)
-
-def process_tool_call(tool_name, tool_input):
-    tool_endpoints = {
-        "get_user": "get_user",
-        "get_order_by_id": "get_order_by_id",
-        "get_customer_orders": "get_customer_orders",
-        "cancel_order": "cancel_order",
-        "update_user_contact": "update_user",
-        "get_user_info": "get_user_info"
-    }
-    
-    if tool_name in tool_endpoints:
-        response = requests.post(f"{BASE_URL}/{tool_endpoints[tool_name]}", json=tool_input, verify=False)
-    else:
-        logger.error(f"Invalid tool name: {tool_name}")
-        return {"error": "Invalid tool name"}
-
-    if response.status_code == 200:
-        return response.json()
-    else:
-        logger.error(f"Tool call failed: {response.text}")
-        return {"error": response.text}
-
-system_prompt = """
-You are a customer support chat bot for an online retailer called BlackBird.
-Your job is to help users look up their account, orders, and cancel orders.
-Be helpful and brief in your responses.
-You have access to a set of tools, but only use them when needed.
-If you do not have enough information to use a tool correctly, ask a user follow up questions to get the required inputs.
-Do not call any of the tools unless you have the required data from a user.
-
-In each conversational turn, you will begin by thinking about your response.
-Once you're done, you will write a user-facing response.
-"""
+client = anthropic.Client(api_key=API_KEY)
 
 def simple_chat(user_message, history):
     # Reconstruct the message history
@@ -180,15 +32,16 @@ def simple_chat(user_message, history):
 
     while iteration_count < MAX_ITERATIONS:
         try:
-            logger.info(f"Sending messages to API: {json.dumps(messages, indent=2)}")
+            logger.info(f"Sending messages to LLM API: {json.dumps(messages, indent=2)}")
             response = client.messages.create(
                 model=MODEL_NAME,
-                system=system_prompt,
+                system=SYSTEM_PROMPT,
                 max_tokens=4096,
                 tools=tools,
                 messages=messages,
             )
-
+            logger.info(f"LLM API response: {json.dumps(response.to_dict(), indent=2)}")
+            
             assistant_message = response.content[0].text if isinstance(response.content, list) else response.content
 
             if response.stop_reason == "tool_use":
@@ -273,10 +126,12 @@ def load_orders_dataset():
     return df
 
 example_inputs = [
-    "What's the status of my orders? My Customer id is 2837622",
-    "Can you confirm my customer info and order status? My email is new_email@example.com",
-    "I'd like to cancel an order",
-    "Can you update my email address to newemail@example.com?",
+    "Can you lookup my user id? My email is...",
+    "I'm checking on the status of an order, the order id is...",
+    "Can you send me a list of my recent orders? My customer id is...",
+    "I need to cancel Order ID...",
+    "I lost my phone and need to update my contact information. My user id is...",
+    "I need to confirm my current user info and order status. My email is...",
 ]
 
 # Create Gradio App
@@ -285,15 +140,20 @@ app = gr.Blocks(theme="sudeepshouche/minimalist")
 with app:
     with gr.Tab("Chatbot"):
         gr.Markdown("# BlackBird Customer Support Chat")
+        gr.Markdown("## leveraging **Claude Sonnet 3.5** for microservice-based function calling")
+        gr.Markdown("FastAPI Backend - runing on Docker:  [blackbird-svc](https://huggingface.co/spaces/dwb2023/blackbird-svc)")
+        gr.Markdown("Data Sources - HF Datasets:  [blackbird-customers](https://huggingface.co/datasets/dwb2023/blackbird-customers)  [blackbird-orders](https://huggingface.co/datasets/dwb2023/blackbird-orders)")
+
         with gr.Row():
             with gr.Column():
                 msg = gr.Textbox(label="Your message")
-                submit = gr.Button("Submit", variant="primary")
-                clear = gr.Button("Clear", variant="secondary")
+                gr.Markdown("⬆️ checkout the *Customers* and *Orders* tabs above 👆 for sample email addresses, order ids, etc.*")
                 examples = gr.Examples(
                     examples=example_inputs,
                     inputs=msg
                 )
+                submit = gr.Button("Submit", variant="primary")
+                clear = gr.Button("Clear", variant="secondary")
             with gr.Column():
                 chatbot = gr.Chatbot()
 
@@ -318,6 +178,5 @@ with app:
     with gr.Tab("Orders"):
         orders_df = gr.Dataframe(load_orders_dataset(), label="Orders Data")
 
-
 if __name__ == "__main__":
     app.launch()

config.py

@@ -0,0 +1,25 @@
+# config.py
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Define the base URL for the FastAPI service
+BASE_URL = "https://dwb2023-blackbird-svc.hf.space"
+
+# LLM Config
+API_KEY = os.getenv('ANTHROPIC_API_KEY')
+MODEL_NAME = "claude-3-5-sonnet-20240620"
+
+SYSTEM_PROMPT = """
+You are a customer support chat bot for an online retailer called Blackbird. 
+Your job is to help users look up their account, orders, and cancel orders.
+Be helpful and brief in your responses.
+You have access to a set of tools, but only use them when needed.  
+If you do not have enough information to use a tool correctly, ask a user follow up questions to get the required inputs.
+Do not call any of the tools unless you have the required data from a user. 
+
+In each conversational turn, you will begin by thinking about your response. 
+Once you're done, you will write a user-facing response. 
+It's important to place all user-facing conversational responses in <reply></reply> XML tags to make them easy to parse.
+"""

response_formatter.py

@@ -0,0 +1,11 @@
+# response_formatter.py
+# may only be needed when using Claude Opus
+# we are using Claude Sonnet 3.5
+def extract_reply(reply):
+    start_tag = "<reply>"
+    end_tag = "</reply>"
+    start_index = reply.find(start_tag) + len(start_tag)
+    end_index = reply.find(end_tag)
+    if start_index != -1 and end_index != -1:
+        return reply[start_index:end_index].strip()
+    return reply

function_orchestrator.py → tool_handler.py

@@ -1,18 +1,18 @@
-import anthropic
-import json
-import re
-import requests
+# tool_handler.py
+import warnings, logging, requests
+from config import BASE_URL
 
-client = anthropic.Client()
-MODEL_NAME = "claude-3-sonnet-20240229"
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-# Define the base URL for the FastAPI service
-BASE_URL = "https://huggingface.co/spaces/dwb2023/blackbird-svc:7860"
+# Suppress the InsecureRequestWarning
+warnings.filterwarnings("ignore", category=requests.urllib3.exceptions.InsecureRequestWarning)
 
 # Define tools
 tools = [
     {
-        "name": "get_user"
+        "name": "get_user",
         "description": "Looks up a user by email, phone, or username.",
         "input_schema": {
             "type": "object",
@@ -115,87 +115,26 @@ tools = [
     }
 ]
 
-# Function to process tool calls
 def process_tool_call(tool_name, tool_input):
-    if tool_name == "get_user":
-        response = requests.post(f"{BASE_URL}/get_user", json=tool_input)
-    elif tool_name == "get_order_by_id":
-        response = requests.post(f"{BASE_URL}/get_order_by_id", json=tool_input)
-    elif tool_name == "get_customer_orders":
-        response = requests.post(f"{BASE_URL}/get_customer_orders", json=tool_input)
-    elif tool_name == "cancel_order":
-        response = requests.post(f"{BASE_URL}/cancel_order", json=tool_input)
-    elif tool_name == "update_user_contact":
-        response = requests.post(f"{BASE_URL}/update_user", json=tool_input)
-    elif tool_name == "get_user_info":
-        response = requests.post(f"{BASE_URL}/get_user_info", json=tool_input)
+    tool_endpoints = {
+        "get_user": "get_user",
+        "get_order_by_id": "get_order_by_id",
+        "get_customer_orders": "get_customer_orders",
+        "cancel_order": "cancel_order",
+        "update_user_contact": "update_user",
+        "get_user_info": "get_user_info"
+    }
+    
+    if tool_name in tool_endpoints:
+        logger.info(f"tool_handler Calling tool: {tool_name}")
+        response = requests.post(f"{BASE_URL}/{tool_endpoints[tool_name]}", json=tool_input, verify=False)
     else:
+        logger.error(f"tool_handle Invalid tool name: {tool_name}")
         return {"error": "Invalid tool name"}
 
     if response.status_code == 200:
+        logger.info(f"tool_handler Tool call successful: {response.json()}")
         return response.json()
     else:
+        logger.error(f"tool_handler Tool call failed: {response.text}")
         return {"error": response.text}
-
-# Function to handle interactive chat session
-def simple_chat():
-    system_prompt = """
-    You are a customer support chat bot for an online retailer called TechNova.
-    Your job is to help users look up their account, orders, and cancel orders.
-    Be helpful and brief in your responses.
-    You have access to a set of tools, but only use them when needed.
-    If you do not have enough information to use a tool correctly, ask a user follow up questions to get the required inputs.
-    Do not call any of the tools unless you have the required data from a user.
-
-    In each conversational turn, you will begin by thinking about your response.
-    Once you're done, you will write a user-facing response.
-    """
-    user_message = input("\nUser: ")
-    messages = [{"role": "user", "content": user_message}]
-    while True:
-        #If the last message is from the assistant, get another input from the user
-        if messages[-1].get("role") == "assistant":
-            user_message = input("\nUser: ")
-            messages.append({"role": "user", "content": user_message})
-
-        #Send a request to Claude
-        response = client.messages.create(
-            model=MODEL_NAME,
-            max_tokens=4096,
-            tools=tools,
-            messages=messages
-        )
-        # Update messages to include Claude's response
-        messages.append(
-            {"role": "assistant", "content": response.content}
-        )
-
-        #If Claude stops because it wants to use a tool:
-        if response.stop_reason == "tool_use":
-            tool_use = response.content[-1] #Naive approach assumes only 1 tool is called at a time
-            tool_name = tool_use.name
-            tool_input = tool_use.input
-            print(f"======Claude wants to use the {tool_name} tool======")
-
-            #Actually run the underlying tool functionality on our db
-            tool_result = process_tool_call(tool_name, tool_input)
-
-            #Add our tool_result message:
-            messages.append(
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "tool_result",
-                            "tool_use_id": tool_use.id,
-                            "content": str(tool_result),
-                        }
-                    ],
-                },
-            )
-        else: 
-            #If Claude does NOT want to use a tool, just print out the text reponse
-            print("\nTechNova Support: " + f"{response.content[0].text}" )
-
-# Start the chat!!
-simple_chat()