Let's look at how to make a request to GPT-4 using Python in a Jupyter notebook.

To follow along, you'll need an API key from OpenAI. If you don't have one, visit [platform.openai.com](https://platform.openai.com) to obtain one.

In the Jupyter Notebook, the first step is to install the OpenAI package:

```bash
pip install openai
```

Next, add a cell and import the `openai` package. It's recommended to use an environment variable to store your API key.

```python
import openai
```

In this example, we'll use the `dotenv` package to load the API key from an .env file:

```python
# second cell
from dotenv import load_dotenv
import os

# third cell
load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')
```


## Making a Request

Here's the basic syntax for making a request with the OpenAI package:

```python
openai.ChatCompletion.create(
  model='gpt-3.5-turbo',  # or 'gpt-4'
  messages=[
    {"role": "user", "content": "tell me a joke"}
  ]  # A list of messages
)
```

The `messages` parameter is a list of dictionaries, even if there is only a single message. Each movie must contain a `role` and `content`

The `role` can be one of the following:

- `’system’`: Sets an overall system directive.
- `’user’`: Represents the user (or developer) asking a question or making a request.
- `’assistant’`: Shows the model the desired response format.

Now, let's add a new notebook cell and create a request to ask GPT-4 about OpenAI:

```python
res = openai.ChatCompletion.create(
    model='gpt-4',
    messages=[
        {
            'role': 'user',
            'content': 'Tell me about OpenAI'
        }
    ]
)
```

## Accessing the Response

The response object contains a lot of information:

![code screen](https://res.cloudinary.com/dwppkb069/image/upload/v1683736289/tips/images-01.-GPT_Requests_Python.mp4/01-gpt_requests_python_25_02-38000-youll-notice-theres-quite-a-bit-of-information-in-here-_yaurkw.png)

What we're interested in is the `assistant's` reply, which is nested inside of `choices` which is a list.

To access the content of the response message, use the following code:

```python
res['choices'][0]['message']['content']
```

This will print the assistant's response, providing the information about OpenAI that we asked the API for.

Learn how you can use the OpenAI package for Python inside of a Jupyter Notebook to communicate with the chat completion API.

OpenAI GPT-4 Requests with Python

[00:00] In this video, I'll show you how easy it is to make a request to GPT-4 using Python. So I'm working in a notebook, and the first thing we have to do is install the OpenAI package. So pip install OpenAI. I've already done this. It will take a moment for you, most likely.


[00:16] And then we have to import OpenAI and provide our API key. So if you haven't gotten an API key yet, you'll need to go to platform.openai.com to get your own API key.

[00:28] Once you have it, all we do is on the OpenAI package, we set OpenAI.APIKey equal to whatever your API key is. Although it's a much better idea to use an environment variable, which is what I'm going to do.

[00:43] There we go. I'm using a package called.env. It's specifically a function load.env. I have a file called.env with my environment variable in it, and then it loads it. I get access to it, and I set OpenAI.APIKey equal to my API key. Okay, so now it's time to make a request.

[01:02] This is the basic syntax for making a request with the OpenAI package. So the first thing you'll notice is that we call OpenAI.chatCompletion.create. We specify a model. If you don't have access to GPT-4, GPT-3.5 Turbo is your best bet. And then we have to specify a list of messages.

[01:20] So this list of messages follows a particular format. I'll talk more about it in a moment. Let me just show you an example. Let's do an OpenAI.chatCompletion.create. I'll set my model here to be GPT-4 because I have access to it for now.

[01:37] And then I provide a list of messages, even if it's just a single message. Each message has to follow this format. It must be an object or in Python a dictionary that has a role, which can be set to system, user, or assistant. You can use the system role to set an overall system directive.

[01:55] The user role is what you'll most commonly use anytime you're asking or requesting anything from the model. And we can also use role set to assistant if we're trying to show the model what we want it to give us back. And then most importantly, we have to provide content, which is the content of the message.

[02:13] So let's start with a very simple, single little message. Role will be user. Again, that refers to me or the developer, the user here talking to the assistant. And then our content, let's ask the model to tell us about OpenAI. All right. And I'm going to save this response into a variable. I'll call it res, and I'll run that cell.

[02:32] When it finishes, here's our response variable. You'll notice there's quite a bit of information in here, but the actual content we want is nested inside of choices, which is a list. We want the first choice, and then we want message, and then finally, we want the content of that message.

[02:50] Notice this message has a role set to assistant. It's the assistant's response. And finally, I'll just print this, and we'll see our nice response we got back, a little bit of information about OpenAI.

## Making Requests to OpenAI's GPT APIs Using JavaScript

In this guide you'll learn how to make requests using JavaScript to OpenAI's GPT APIs.

Most of the documentation on OpenAI's website shows Python examples, but there is a Node client from OpenAI called `openai-node` on GitHub.

Make sure you have an API key for OpenAI, as it is required for the client.

### Installing openai-node

First, install the `openai-node` package using npm:

```bash
npm install openai
```

### Basic Query in JavaScript

Create an `app.js` file.

In this example we're using an environment variable for our API key using the `dotenv` package. You can also hardcode the key, but it's not recommended.

```bash
require("dotenv").config();
```

Next we'll bring in the OpenAI package, then create a new configuration instance with the API key variable:

```js
const { Configuration, OpenAIApi } = require('openai');

const configuration = new Configuration({ apiKey: process.env.OPENAI_API_KEY });
```

Then we can create a new instance of OpenAIApi with the configuration:

```js
const openai = new OpenAIApi(configuration);
```

Everything is now in place to make requests!

### Making a Request

To make a request we'll be using the `createChatCompletion` method from openai.

Here's an example of an async function called `getPoem`. The `createChatCompletion` method returns a promise, so we use `await` to handle it.

The `modelName` will be either `gpt-3.5-turbo` or `gpt-4`. Then we have an array of `messages` that will contain at least one object with a `role` and `content`.

In this case, the message will be a `user` prompting for a rhyming poem:

```js
async function getPoem() {
  const response = await openai.createChatCompletion({
    modelName: 'gpt-4',
    messages: [
      {
        role: 'user',
        content: 'generate a short rhyming poem',
      },
    ],
  });

  console.log(response.data.choices[0].message.content)
}
```

The content of the response message is accessed with:

```js
response.data.choices[0].message.content
```

Now every time you run `getPoem()`, a new rhyming poem will be displayed in the console:

![gptrequests](https://res.cloudinary.com/dwppkb069/image/upload/v1683736289/tips/images-02-js_gpt4_requests.mp4/02-js_gpt4_requests_32_03-42000-theres-no-divider-between-the-two--but-this-is-the-first-poem--and-this-is-the-second-poem_p13joe.png)

That's it! Now you know how to make requests to OpenAI's GPT APIs using JavaScript and the `openai-node` client.

OpenAI offers an npm package that allows you to communicate with the chat completion API, allowing you to take advantage of the latest models behind ChatGPT.

OpenAI API Requests in JavaScript

[00:00] In this quick video, I'm going to show you how to make requests using JavaScript to OpenAI's GPT APIs. So most of the documentation on OpenAI's website shows Python examples, but there is a Node client put out by OpenAI called OpenAI-Node on GitHub that we can use.

[00:19] The first step, of course, is to install it. npm install openai. And if you haven't already signed up for an API key, you'll need to do that because the client needs the API key. So this is my app.js file. I'm just going to do a very basic query in here.

[00:34] And the first step is, of course, to require OpenAI, which we just installed. Specifically, though, we're going to require configuration and OpenAI API. The next step is to provide our API key to a new configuration instance.

[00:51] So I'm using an environment variable. Of course, you could just hard code your key in here, but that's not really good practice. But if you just want to get up and running, you can do that.

[00:59] So I have mine in a.env file. I'm using the.env package to load my environment variables and then grabbing one of them called OpenAI API key and assigning it here.

[01:12] Once we have this configuration, the second step is to create a new instance of OpenAI API where we pass in our configuration. So if you get to that point and you have a valid API key, we now should be able to make requests. So how do we make requests?

[01:28] If you look at the documentation for this package, it's a little bit out of date, and it shows the create completion method, which still works. But this does not support the chat endpoint, meaning it does not support GPT 3.5 Turbo or GPT 4.

[01:43] It only supports Text DaVinci 003 as the most recent model. So instead, what we need to do is use a method that exists, it's just not on the readme called create chat completion. And this returns a promise. So we're going to want to await this and put it in some sort of async function.

[02:02] I'll call my async function get poem. We will await this. We'll call this response or something that we get back. And then we have to provide an object in here that has a couple of pieces. The first thing is the model name that we want to use. I'm going to use GPT 4.

[02:20] And then we have to provide a list of messages or an array of messages. Now, I have a separate video talking about the messages format, but the bare minimum here is a single message in an array. And each message has a role. We'll set this first one to user. And I'm going to ask it to generate me a poem.

[02:38] So the content will be generate a short rhyming poem. I'm not even going to give a direction as to what the poem should be about. So we await this. This will make our API request, assuming our key is configured properly.

[02:54] Then we need to look at the response.data. And maybe I'll just start by printing that out. Response.data. Let's execute get poem just one time down at the bottom here. And let's run our file, app.js. All right. So we get some data back.

[03:10] The stuff we care about for the most part is inside of choices, which is an array. We want the first choice, the message. It's a little bit annoying. It looks like this. Response.data.choices. We want the zero with element. And then we want.message.content. And that will give us the content of the response message.

[03:29] So let's try running this. And maybe we'll do it twice to get two different poems. Okay. So we'll wait. And here's our first poem. There's no divider between the two, but this is the first poem, and this is the second poem. Not the most useful query, but that's beside the point.

[03:44] What matters most here is seeing how to make a request in JavaScript using the OpenAI client.

The OpenAI temperature parameter can be provided to any of the GPT family of models.

It's very useful, but it's not all that self-explanatory.

Temperature is a number between 0 and 2, with a default value of 1 or 0.7 depending on the model you choose.

The temperature is used to control the randomness of the output.

When you set it higher, you'll get more random outputs. When you set it lower, towards 0, the values are more deterministic.

![temp screenshot](https://res.cloudinary.com/dwppkb069/image/upload/v1683736291/tips/images-03-temperature.mp4/03-temperature_3_00-35000-so-let-me-show-you-an-example_j2vdfa.png)

## Sentence Completion Example

For this example, we're working in a Python notebook, but this would easily work with JavaScript as well.

We have an environment variable for the OpenAI API key, and we're making a very simple completion using `gpt-3.5-turbo`.

The message we send asks the model to complete the sentence "the key to happiness is" with two words.

```python
res = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[{"role": "user", "content": "Complete the sentence with two words. The key to happiness is"}]
)
```

With the default temperature, running this will usually return "contentment and gratitude" or "inner peace".

![code different](https://res.cloudinary.com/dwppkb069/image/upload/v1683736290/tips/images-03-temperature.mp4/03-temperature_9_01-09000-we-got-something-different--inner-peace_a4zmq1.png)

## Increasing and Decreasing the Temperature

If we increase the temperature parameter to the maximum of 2 by adding `temperature=2, it's going to give me a much more varied output: "personal fulfillment", "simplicity and gratitude", "contentment and balance", "satisfaction and appreciation", "different for everybody", "gratitude and teamwork", "mindfulness and empathy".

![screenshot output](https://res.cloudinary.com/dwppkb069/image/upload/v1683736290/tips/images-03-temperature.mp4/03-temperature_10_01-21000-its-going-to-give-me-a-much-more-varied-output-_xalt3r.png)

Generally I wouldn't recommend increasing the temperature so high, but it works for this example.

Moving the temperature all the way down to zero, it's going to return "contentment and gratitude" pretty much every single time. It's not guaranteed to be the same, but it is most likely that it will be the same output.

## Haiku Example

Increasing the temperature will produce more interesting and creative output.

However, going too high has its own issues.

In this example, we ask the model to write a haiku.

```python
res = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  temperature=0.9,
  messages=[{"role": "user", "content": "Write a haiku"}]
)
```

With the temperature at 0.9, it's going to produce nice haikus that are typically nature-themed:

```md
flowers in the field,
dancing in the summer breeze,
nature's symphony.
```

```md
Solitary bee
over forgotten blossoms,
April cold leaves.
```

Moving the temperature all the way up to 2, we'll certainly get something different, but it won't always be coherent:

```md
Easy tropical flips-
trade palms winds filter music_,
without flotates spring waves
```

First of all, this is not a haiku. It also starts introducing some very weird stuff like underscores and a made up word.

The output can get even more strange:

![output](https://res.cloudinary.com/dwppkb069/image/upload/v1683736290/tips/images-03-temperature.mp4/03-temperature_23_02-58000-so-if-youre-wondering-how-this-works--without-going-into-too-much-detail-_gizp4i.png)

It doesn't make any sense.

This is why I generally recommend sticking with a temperature between 0 and 1.

## How Temperature Works

Without going into too much detail, there's some math behind the scenes of the temperature.

Basically, the temperature value we provide is used to scale down the probabilities of the next individual tokens that the model can select from.

With a higher temperature, we'll have a softer curve of probabilities. With a lower temperature, we have a much more peaked distribution. If the temperature is almost 0, we're going to have a very sharp peaked distribution.

Here's a visualization:

![screenshot](https://res.cloudinary.com/dwppkb069/image/upload/v1683736290/tips/images-03-temperature.mp4/03-temperature_30_03-25000-if-temperature-is-like-almost-0--were-going-to-have-a-very-sharp-peaked-distribution_wprxqo.png)

### Recommended Temperatures

I recommend starting somewhere around 1 for the temperature.

If you need something to be more deterministic, you can decrease it. If you want some spicier results, you can increase it above 1.

Just remember, if you go too high, you will get some really weird output!

The temperature parameter in an OpenAI API request influences how creative your prompt's output will be.

Understanding OpenAI's Temperature Parameter

## Understanding Tokens in OpenAI APIs

When working with any of the OpenAI APIs, one of the most important concepts to understand is tokens.

GPT models don't work with words as we know them in the English language, but instead break things down into a system of tokens which are usually pieces of words, although some tokens are actually full words.

On average, a token is about four characters of English text (it does vary from language to language).

![hamburger token](https://res.cloudinary.com/dwppkb069/image/upload/v1683736291/tips/images-04-tokens.mp4/04-tokens_2_00-38260-so-theres-two-main-reasons-this-matters_l3lxsz.png)

As an example, the phrase "I like hamburgers" is three English words but it's actually five separate tokens in the world of GPT.

## Pricing and API Request Cost

Tokens determine billing and how much our API requests cost.

OpenAI charges based on the number of tokens that we use, both in the prompt plus the tokens in the output. They multiply the number of tokens by the price per token, which varies from one model to the next.

As of this writing, there are some very cheap models, along with the comparatively expensive GPT-4.

![pricing models](https://res.cloudinary.com/dwppkb069/image/upload/v1683736291/tips/images-04-tokens.mp4/04-tokens_4_00-58820-so-theres-some-very-cheap-models-_j7dtto.png)

Although for GPT-4, there's two different price points, and I'll talk about why in a moment. If you look at GPT-3.5 Turbo, it is significantly cheaper, $0.002 for 1,000 tokens.

## Tokenizer Tool

There's a tool called the Tokenizer on the OpenAI website.

While the tool does not support GPT-4 or 3.5, it will show us the tokens behind the scenes.

Let's look at the phrase "hello world my name is colt":

![token screenshot](https://res.cloudinary.com/dwppkb069/image/upload/v1683736291/tips/images-04-tokens.mp4/04-tokens_11_01-34260-you-can-see-some-of-these-tokens-are-full-words-_lldsgx.png)

You can see some of these tokens are full words, and they often will have a leading space. But then something like "col" isn't really a word, and the final letter "T" is its own individual token.

We would be billed seven tokens for this individual phrase.

### Token Usage Example

Here is an example of simple sentiment analysis request in Python. The prompt was a list of messages, and the sentiment output it gave was the word "neutral."

![screenshot](https://res.cloudinary.com/dwppkb069/image/upload/v1683736291/tips/images-04-tokens.mp4/04-tokens_17_01-59900-this-is-the-output-it-gave-me--the-word-neutral_hdmeiz.png)

Looking at the usage portion of the response, we can see the total number of tokens used.

In this case, the number of tokens in the completion (output) was one token. The number of tokens in the prompt was 59 tokens, so our total was 60 tokens.

In this example the request used GPT-4, so I would be billed for 60 tokens at the rate of six cents per 1,000 tokens (at the time of this writing).

## Maximum Context Window

The other reason tokens really matter is that there is a *maximum context window* for each model. This is the total number of tokens that each model can work with at a given time.

For the base `gpt-4`, that number is 8,192 tokens. However there are different variations like `gpt-4-32k` that have a maximum of 32,768 tokens, though it comes at double the price.

This context window is not just the length of the input, but the maximum number of tokens the model can work with period. It's the input plus the output tokens.

Generally token limits are not a problem for smaller tasks, though larger tasks like summarizing a book or really long chat conversations may give you problems when you run out of tokens.

It's a good idea to be aware of the amount of tokens you use!

Understand how tokens are used by OpenAI for providing context for your requests, as well as how you will be billed for using different GPT models.

The Role of Tokens for GPT Models

[00:00] If you're working with any of the OpenAI APIs, one of the most important concepts to understand is tokens. So the GPT models don't work with words as we know them in the English language, but instead break things down into a system of tokens, which are basically pieces of words, although some tokens are actually full words.

[00:19] On average, a token is about four characters of English text. Again, that's in English, it does vary from language to language. So as an example, the phrase, I like hamburgers, is three English words, but it's actually five separate tokens in the world of GPT. So there's two main reasons this matters.

[00:38] One is for billing and how much our API requests cost. OpenAI will charge us based on the number of tokens that we use, both in the prompt plus the tokens in the output. So it adds them together, and then it multiplies the number of tokens by the price per token, which varies from one model to the next.

[00:56] So there's some very cheap models, and then there's a very expensive model, which is GPT-4. Although for GPT-4, there's two different price points, and I'll talk about why in a moment. If you look at GPT-3.5 Turbo, it is significantly cheaper, $2.002 for 1,000 tokens.

[01:14] So there's a tool called the Tokenizer on the OpenAI website. It does not support GPT-4 or 3.5. But if we type things in here like, hello world, my name is Colt, it will show us the tokens behind the scenes. You can see some of these tokens are full words,

[01:34] and they often will have a leading space. But then something like this right here, Colt isn't really a word anyway, but the final letter T is its own individual token. We would be billed seven tokens for this individual phrase. When we make a request, like this one I'm making in Python, a simple sentiment analysis request.

[01:53] This is my prompt, a list of messages. This is the output it gave me, the word neutral. It assessed the sentiment was neutral in the tweet that I provided. But if we look at the usage portion of the response, it tells us the number of tokens in the completion, that's the output, was one token. So this was one token.

[02:12] The number of tokens in the prompt was 59 tokens. So all of this was 59 tokens. Then the total tokens is the sum of the two, 60 tokens. I was using GPT-4. So I would be billed at six cents per 1,000 tokens, and I used 60 tokens. Now, the other reason tokens really matter is that there is

[02:30] a maximum context window, a maximum number of tokens that each model can work with at a given time. So for GPT-4, that number is 8,192 tokens. Although there is a much larger context window available, if you use a different variation,

[02:47] GPT-4 32K, this is way more expensive. That's the 12 cents per 1,000 tokens compared to the six cents for 1,000 tokens. So this context window is not just the length of the input, but it's actually the maximum number of tokens the model can work with period. It's the input plus the output tokens.

[03:06] If we look at other models like 3.5 Turbo, 4,096 tokens is its context window. Generally, for a lot of the prompts that I write, it's not a problem. But if I'm trying to summarize a book or have a really long chat conversation, you can start to run out of tokens, and that can be a big problem. So in a separate video,

[03:24] I'll cover different ways of counting

[03:26] tokens programmatically using a library called TickToken.

Tips

A collection of programming tips for your daily workflow.

OpenAI GPT-4 Requests with Python

OpenAI API Requests in JavaScript

Understanding OpenAI's Temperature Parameter

The Role of Tokens for GPT Models