Customer Service Chatbot with tools and tracing

This guide explores building a customer service bot with tools and tracing using Opper. The bot demonstrates handling order status inquiries, product queries, and other customer service tasks while maintaining a natural conversation flow.

Key Features

Intent classification to understand user requests (get_order_status etc)
Control of intent requirements (email and order id required)
Tool support for performing outside system actions (query database)
Conversation history tracking
Natural language responses
Tracing for monitoring and debugging

Example run

Below is an example conversation showing how the bot handles an order status inquiry, followed by the implementation code.

# Example conversation demonstrating order status inquiry:

User: Hello
Assistant: Hi there! How can I assist you today?

User: I placed an order the other day and I wonder when to expect it
Assistant: Could you please provide me with your order ID and the email address you used to place the order? This will help me check the status for you.

User: my order id is 123123
Assistant: Thank you for providing your order ID. Could you also share the email address you used to place the order so I can look up the details for you?

User: santaclause@clau.se
Assistant: I'm sorry, but I couldn't find an order with the ID 123123. Could you double-check the order ID and make sure it's correct? If you need further assistance, please let me know!

User: oh actually my email is santa@clau.se
Assistant: Thank you for the updated email address. I have found your order with ID 123123, and it is currently out for delivery to Snowy Mountain 123, 421 23, Greenland. If you need further assistance, please let me know!

User: What did I order? I forgot
Assistant: Currently, I don't have details on the contents of your order. For more information, please check your email or the confirmation message you received after placing the order. If you need further assistance, feel free to ask!

User: ok thanks! 
Assistant: You're welcome! If you have any more questions or need further assistance in the future, feel free to reach out. Have a great day!

Implementation

Let's look at the complete implementation of our customer service bot. The code below demonstrates how we use Opper's function calling capabilities to handle intents, extract order information, and generate appropriate responses.

from opperai import Opper, trace
from pydantic import BaseModel
from typing import Literal
import os

# Initialize Opper client
opper = Opper(api_key=os.getenv("OPPER_API_KEY"))

# A test "database"
orders = {
    123123: {
        "email": "santa@clau.se", 
        "status": "delivering",
        "created_date": "2024-11-03", 
        "updated_date": "2024-11-06",
        "adress": "Snowy Mountain 123, 421 23, Greenland",
        "purchase": "Large sled 1999 SEK"
        }
    }

# A classification of the conversation
class IntentClassification(BaseModel):
    thoughts: str
    intent: Literal["get_order_status", "query_products", "unsupported"]

# Function to determine intent of conversation
def determine_intent(messages):
    intent, _ = opper.call(
        name="determine_intent",
        instructions="Analyze the user message and determine their intent. Supported intents are get_order_status and query products.",
        input={"messages": messages},
        output_type=IntentClassification
    )
    return intent
    
# A parsed order request
class ParsedOrder(BaseModel):
    thoughts: str
    order_id: int | None = None
    email: str | None = None

# Function to extract order data from conversation
def extract_order_from_messages(messages):
    order_info, _ = opper.call(
        name="extract_order_info",
        instructions="Extract order ID and email from the conversation if present",
        input={"messages": messages},
        output_type=ParsedOrder
    )
    return order_info

# Function to get the requested order
def get_order(id, email):
    if id in orders and orders[id]["email"] == email:
        return orders[id]
    else:
        return None

# Function to process messages
def process_message(messages):

    # We first determine intent with the conversation
    intent = determine_intent(messages)

    # Process based on intent
    if intent.intent == "get_order_status":

        # Extract requested order information
        order_request = extract_order_from_messages(messages)

        # Verify we have all needed order info
        if not order_request.order_id or not order_request.email:
            return  f"Need {'order ID and email' if not order_request.order_id and not order_request.email else 'order ID' if not order_request.order_id else 'email'}"

        order = get_order(id=order_request.order_id, email=order_request.email)
        if order:
            return {
                    "order_id": order_request.order_id,
                    "status": orders[order_request.order_id]["status"],
                    "email": orders[order_request.order_id]["email"],
                    "address": orders[order_request.order_id]["adress"]
                }
        else:
            return f"Could not find an order with id {order_request.order_id}"

    # Here we could have different tools      
    #elif intent.intent == "query_products": 
    #    return None
    
    elif intent.intent == "unsupported": 
        return f"Request is currently not supported: {messages[-1]}"
    
    else:
        return None

# Function to build a friendly AI response
def bake_response(messages):
    response, _ = opper.call(
        name="generate_response",
        instructions="Generate a helpful, friendly but brief response to the user's message in the conversation.",
        input={"messages": messages},
        output_type=str,
        # stream=True
    )
    return response

@trace
def run():
    # Here we have a conversatonal loop of user, function and assistant messages
    messages = []

    while True:
        
        # We make each queston/response a turn
        with opper.traces.start(name="on_message") as message_trace: 

            # Get user input
            user_input = input("User: ")
            if user_input.lower() == "quit":
                break

            messages.append({
                "role": "user",
                "content": user_input
            })

            # Analyse the conversation and return an analysis
            analysis = process_message(messages)

            messages.append({
                "role": "function",
                "content": analysis
            })

            # Bake response to the user 
            response = bake_response(messages)

            print(f"Assistant: {response}")

            messages.append({
                "role": "assistant",
                "content": response
            })
            
            # We set the trace input and end output values to make them nice to look at
            message_trace.update(input = user_input, output = response)
            
            # Here we could add thumbs up on this response 
            # message_trace.save_metric("thumbs_up", 1, "User pressed thumbs up button"))

if __name__ == "__main__":
    run()

Observing sessions with traces

The tracing capabilities allow us to monitor and debug the bot's behavior. Here's a visualization of a typical conversation trace: