Tutorial da API do GPT-4.5: Primeiros passos com a API da OpenAI

O que é o GPT 4.5?

O GPT-4.5 é o modelo de linguagem mais recente da OpenAI, projetado para melhorar a fluência da conversação, a consciência contextual e a precisão factual. Ele se baseia nos modelos anteriores, oferecendo respostas mais naturais, melhor adaptação de tom e menos alucinaçõeso que o torna adequado para aplicativos como chatbots, geração de conteúdo e automação de tarefas.

No entanto, ao contrário dos modelos da série O da OpenAI, o GPT-4.5 não se baseia no raciocínio passo a passo, portanto, não é a melhor opção para a solução de problemas complexos em áreas como matemática ou programação. Se precisar de um modelo de raciocínio para seu aplicativo, você pode ler este tutorial sobre API OpenAI O1.

Para uma análise mais detalhada dos pontos fortes, das limitações e das comparações de benchmark do GPT-4.5, confira nossa análise completa de GPT-4.5.

API GPT-4.5: Como se conectar à API da OpenAI

Nesta seção, examinaremos as etapas para você se conectar à API da OpenAI, incluindo a criação de uma chave de API e a configuração do seu ambiente Python.

Criando uma chave de API

Para usar a API da OpenAI, precisamos criar uma chave de API. Essa chave é usada para autenticar nosso cliente Python com a API.

1. Navegue até a página da página da chave da API da OpenAI.

2. Você precisará fazer login ou criar uma conta da OpenAI se ainda não tiver uma.

3. Clique no botão "Create new secret key" (Criar nova chave secreta).

4. Você pode escolher um nome para ele, mas não há problema em deixar as opções padrão.

5. Clique no botão "Create secret key" (Criar chave secreta).

6. Quando a chave for exibida, você poderá copiá-la. Você não conseguirá vê-la novamente mais tarde. Se você o perder, sempre poderá excluí-lo e criar um novo.

7. Crie um arquivo chamado .env na mesma pasta em que você escreverá o código Python e cole a chave lá com o seguinte formato:

OPENAI_API_KEY=<paste_your_key_here>

Preços da API

A API da OpenAI não é gratuita. Dependendo do modelo usado, você incorrerá em taxas diferentes. Todos os detalhes sobre preços podem ser encontrados na sua página de preços.

Essas taxas são diferentes das assinaturas para usar o ChatGPT em sua interface on-line. Ao usar a API, pagamos por mensagem em vez de pagar um valor fixo por mês. Para uso regular, essa pode ser uma maneira muito mais barata de acessar seus modelos.

Neste tutorial, usaremos seu modelo mais recente, o GPT-4.5. Esse é o modelo generalista mais avançado.

Os preços não são definidos por mensagem, mas sim por token. Quando enviamos uma mensagem para um LLM, ela é dividida em tokens. Não existe uma fórmula confiável para converter palavras em tokens, mas, para se ter uma ideia, você pode estimar que um token é mais ou menos 3/4 de uma palavra.

Isso significa que o preço acima corresponde aproximadamente a 750.000 palavras. 

Para usar a API, precisamos adicionar créditos à nossa conta. Você pode fazer isso na página de faturamento da OpenAI.

Configuração do ambiente Python 

A OpenAI fornece um cliente Python que facilita a interação com sua API. Para usá-lo, precisamos instalá-lo, bem como alguns outros pacotes para nos ajudar a carregar a chave que criamos anteriormente.

Usaremos o Anaconda para criar um ambiente Python e instalar as dependências necessárias. Essa é uma maneira mais limpa de fazer isso, pois evita possíveis conflitos com outros pacotes Python que você possa ter.

Depois de instalar o Anaconda, podemos criar o ambiente usando o comando do terminal:

conda create -n gpt45 -y python=3.9

Esse comando cria um ambiente chamado gpt45 que usa a versão 3.9 do Python. A opção -y é usada para responder automaticamente sim a todas as perguntas no processo de criação.

Em seguida, ativamos o ambiente usando:

conda activate gpt45

Por fim, instalamos as dependências necessárias.

• pip install openai: Instale a biblioteca Python do OpenAI.
• pip install python-dovenv: Instale um pacote para carregar a chave de API do arquivo .env que criamos anteriormente.

Fazendo nossa primeira solicitação de API

Estamos prontos para começar a escrever código Python para fazer solicitações à API da OpenAI.

Comece criando um arquivo chamado script.py. É aqui que escreveremos o código.

Em seguida, importamos os pacotes:

from openai import OpenAI
from dotenv import load_dotenv
import os

Em seguida, carregamos a chave da API e inicializamos o cliente:

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=api_key)

Por fim, enviamos uma mensagem. Para começar, enviaremos apenas "Hello":

completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=[
        {
            "role": "user",
            "content": "Hello"
        }
    ]
)
print(completion.choices[0].message.content)

O parâmetro model é usado para especificar o modelo que você deseja usar. Para experimentar outros modelos, substitua-o por outro.

Podemos executar o script usando:

python script.py

Aqui está o resultado:

Hello! How can I help you today?

Criando um chatbot GPT-4.5 com Python

Nesta seção, aproveitaremos nosso script anterior para criar um chatbot interativo que nos permita conversar com o GPT-4.5 no terminal.

Para fazer isso, precisamos alterar nosso script para:

1. Receber informações do usuário.
2. Mantenha o controle da conversa e envie as mensagens anteriores, bem como a nova solicitação.
3. Repita esse procedimento até que o usuário saia.

Permitir que o usuário insira um prompt

Para ler a entrada do usuário no terminal, usamos a função input(). Quando for chamado, ele aguardará que o usuário insira o texto e, em seguida, retornará esse texto.

prompt = input("> ")
print(prompt)

Veja como fica quando você executa isso no terminal:

> Hello
Hello

O loop de bate-papo

Para implementar o bate-papo, usaremos um loop que será executado até que o prompt seja igual a "exit". Essa será a lógica do loop principal:

while True:
  prompt = input("> ")
  if prompt == "exit":
    exit()
  # Prompt processing goes here

Processando o prompt

O modelo não mantém um histórico das mensagens que enviamos anteriormente. Ele trata cada mensagem como uma nova mensagem. Portanto, para obter um comportamento de bate-papo, precisamos fornecer todas as mensagens que foram enviadas até o momento, juntamente com o novo prompt. Para isso, mantemos o histórico do bate-papo.

As mensagens dos usuários devem ter o seguinte formato:

{
  "role": "user",
  "content": <user prompt>
}

A resposta do modelo deve ter a função "assistant".

{
  "role": "assistant",
  "content": <model answer>
}

Com isso em mente, aqui está a implementação completa do bate-papo:

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

client = OpenAI(api_key=api_key)

# Initialize the chat history
chat_history = []
while True:
    prompt = input("> ")
    if prompt == "exit":
        exit()
    # Add the user message to the chat history
    chat_history.append({
        "role": "user",
        "content": prompt,
    })
    # Send the full chat history
    completion = client.chat.completions.create(
        model="gpt-4.5-preview", messages=chat_history
    )
    # Display the answer
    answer = completion.choices[0].message.content
    print(answer)
    # Add the answer to the chat history
    chat_history.append({
        "role": "assistant",
        "content": answer,
    })

Exemplo de bate-papo

Para testar o bate-papo, podemos executá-lo usando o comando:

python script.py

Em seguida, podemos começar a conversar inserindo nosso prompt no terminal. Aqui está um exemplo de bate-papo:

O exemplo mostra dois prompts. Primeiro, pedimos ao modelo que nos mostre um exemplo de como fazer um loop for em Python. Em seguida, para testar se o histórico de bate-papo é enviado corretamente, pedimos que você faça o mesmo em Javascript.

Como fornecemos o histórico do bate-papo, o modo pode entender o que queremos dizer com "fazer o mesmo" e nos dá um exemplo de um loop for em Javascript.

Conclusão

Neste tutorial, exploramos como você pode configurar e conversar com o modelo GPT-4.5 da OpenAI usando Python. Aprendemos a criar uma chave de API da OpenAI e a utilizá-la em nosso ambiente Python, o que nos permite interagir com o GPT-4.5 fora da plataforma baseada em assinatura da OpenAI.

Cobrimos a configuração de um ambiente Python usando o Anaconda, instalando os pacotes necessários e fazendo nossa primeira solicitação à API OpenAI.

Por fim, criamos um chatbot simples baseado em terminal interativo, mantendo um histórico de conversas.