One of the exciting things about a large
language model is you can use it to build a custom chatbot
with only a modest amount of effort. ChatGPT, the web interface,
is a way for you to have a conversational interface,
a conversation via a large language model. But one of the
cool things is you can also use a large language model to
build your custom chatbot to maybe play the role of an AI
customer service agent or an AI order taker for a restaurant.
And in this video, you learn how to do that for yourself.
I’m going to describe the components of
the OpenAI ChatCompletions format in more
detail, and then you’re going to build a chatbot yourself. So let’s
get into it. So first, we’ll set up the OpenAI Python package as
So chat models like ChatGPT are actually trained
to take a series of messages as input
and return a model-generated message as output. And
so although the chat format is designed to make multi-turn conversations
like this easy, we’ve kind of seen through the previous videos
that it’s also just as useful for single-turn tasks without any conversation.
And so next, we’re going to kind of define two helper functions. So
this is the one that we’ve been using throughout all the videos,
and it’s the getCompletion function. But if you kind
of look at it, we give a prompt, but then kind of
inside the function, what we’re actually doing is putting this prompt
into what looks
like some kind of user message. And this is because the
ChatGPT model is a chat model, which means it’s trained to take a series
of messages as input and then return a model-generated message
as output. So the user message is kind of the input, and
then the assistant message is the output.
So, in this video, we’re going to actually use
a different helper function, and instead of kind of
putting a single prompt as input and getting
a single completion, we’re going to pass in a list of messages. And these
messages can be kind of from a variety
of different roles, so I’ll describe those. So here’s an example of
a list of messages. And so, the first message is
a system message, which kind of gives an overall instruction, and then after
this message, we have kind of
turns between the user and the assistant. And this would kind
of continue to go on. And if you’ve ever used ChatGPT, the
web interface, then
your messages are the user messages, and then ChatGPT’s
messages are the assistant messages. So the system message helps
to kind of set the behaviour and persona
of the assistant, and it acts as kind of a high-level instruction
for the conversation. So you can kind of think of it as whispering
in the assistant’s ear and kind of guiding it’s responses without the
user being aware of the system message. So, as the user, if
you’ve ever used ChatGPT, you probably don’t know what’s
in ChatGPT’s system message, and that’s kind of the intention. The benefit
of the system message is that it provides you, the developer, with
a way to kind of frame the conversation without making the
request itself part of the conversation. So you can
kind of guide the assistant and kind of whisper in
its ear and guide its responses without making the user aware.
So, now let’s try to use these messages in a conversation.
So we’ll use our new helper function to get the
completion from the messages.
And we’re also using a higher temperature.
So the system message says, you are an assistant
that speaks like Shakespeare. So this is us kind of describing to
the assistant how it should behave. And then the first user message is,
tell me a joke. The next is, why did the chicken cross the road?
And then the final user message is, I don’t know.
So if we run this,
the response is to get to the other side. Let’s try again.
To get to the other side, faire so, madame,
tis an olden classic that never fails. So there’s
our Shakespearean response.
And let’s actually try one more thing, because
I want to make it even clearer that
this is the assistant message. So here, let’s just
go and print the
entire message response.
So, just to make this even clearer, uhm, this
response is an assistant message. So, the role is assistant
and then the content is the message itself. So, that’s
what’s happening in this helper function. We’re just
kind of passing out the content of the message.
now let’s do another example. So, here our messages are, uhm, the
assistant message is, you’re a friendly chatbot and the first
user message is, hi, my name is Isa. And we want to, uhm,
get the first user message. So, let’s execute this. The
first assistant message.
And so, the first message is, hello Isa, it’s nice to meet you. How
can I assist you today?
Now, let’s try another example.
So, here our messages are, uhm, system message, you’re
a friendly chatbot and the first user message is, yes,
can you remind me
what is my name? And let’s get the response.
And as you can see,
the model doesn’t actually know my name.
So, each conversation with a language model is a standalone
interaction which means that you must provide all relevant
messages for the model to draw from in the current conversation.
If you want the model to draw from or, quote unquote,
remember earlier parts of a conversation,
you must provide the earlier exchanges in the
input to the model. And so, we’ll refer to this as context. So, let’s
So, now we’ve kind of given the context that the model needs, uhm, which
is my name in the previous messages and we’ll ask
the same question, so we’ll ask what my name is.
And the model is able to respond because it has
all of the context it needs, uhm, in this kind of list of
messages that we input to it.
So now you’re going to build your own chatbot.
This chatbot is going to be called orderbot, and
we’re going to automate the collection of
user prompts and assistant responses in order to build
this orderbot. And it’s going to take orders at a pizza restaurant, so
first we’re going to define this helper function, and what this
is doing is it’s going to kind of collect our user messages
so we can avoid typing them in by hand in
the same, in the way that we did above, and this is going
to kind of collect prompts from a user
interface that will build below, and then append it
to a list called context, and then it will call the model with
that context every time. And the model response
is then also added to the context, so the kind of
model message is added to the context, the user message is
added to the context, so on, so it just kind of grows longer and
This way the model has the information it needs to
determine what to do next. And so now we’ll
set up and run this kind of UI to display the order bot, and
so here’s the context, and it contains the system message that
contains the menu,
and note that every time we call the language model we’re
going to use the same context, and the context is building
up over time.
And then let’s execute this.
Okay, I’m going to say, hi, I would like to order a pizza.
And the assistant says, great, what pizza would you like to order?
We have pepperoni, cheese, and eggplant pizza.
How much are they?
Great, okay, we have the prices.
I think I’m feeling a medium eggplant pizza.
So as you can imagine, we could kind of continue this conversation,
and let’s kind of look at what we’ve put in the system message.
So you are order bot, an automated service
to collect orders for a pizza restaurant.
You first greet the customer, then collect the order,
and then ask if it’s a pickup or delivery. You
wait to collect the entire order, then summarize it and check
for a final time if the customer wants
to add anything else. If it’s a delivery, you can
ask for an address. Finally, you collect the payment. Make sure
to clarify all options, extras, and sizes
to uniquely identify the item from the menu. You respond
in a short, very conversational, friendly style.
The menu includes, and then here we have the menu.
So let’s go back to our conversation and let’s see
if the assistant kind of has been following the instructions.
Okay, great, the assistant asks if we want any toppings
which we kind of specified an assistant message.
So I think we want no extra toppings.
Things… sure thing. Is there anything else we’d
like to order? Hmm,
let’s get some water. Actually,
Small or large? And this is great because we kind of
asked the assistant in the system message to
kind of clarify extras and sides.
And so you get the idea and please feel free
to play with this yourself. You can pause the video and just go
ahead and run this in your own notebook on the left.
And so now we can ask the model to create a JSON
summary that we could send to the order
system based on the conversation.
So we’re now appending another system message which is an
instruction and we’re saying create a JSON summary of
the previous food order, itemize the price for each item, the fields
should be one pizza, include side,
two lists of toppings, three lists of drinks,
and four lists of sides, and finally the total price.
And you could also
use a user message here, this does not have to be a system
So let’s execute this.
And notice in this case we’re using a lower
temperature because for these kinds of tasks we want
the output to be fairly predictable. For
a conversational agent you might want to use
a higher temperature, however in this case I
would maybe use a lower temperature as well
because for a customer’s assistant chatbot you might want
the output to be a bit more predictable as well.
And so here we have the summary of our order and so
we could submit this to the order system if we wanted to.
So there we have it, you’ve built your very own order chatbot. Feel
free to kind of customize it yourself and play around with the
system message to kind of change the behavior of the chatbot and
kind of get it to act as different personas
with different knowledge.