Como Integrar Modelos OpenAI GPT em Seu Projeto Django

O autor selecionou o Programa de Auxílio Direto para receber uma doação como parte do programa Escreva por Doações.

Introdução

Os modelos OpenAI GPT ganharam popularidade devido ao seu amplo uso na geração de conteúdo de texto para diversas tarefas, como redação de e-mails, resposta a perguntas frequentes de atendimento ao cliente e tradução de idiomas, entre outras.

Esses modelos GPT geralmente são utilizados por meio do ChatGPT, um chatbot lançado pela OpenAI, ou através de APIs e bibliotecas que oferecem maior controle. Este tutorial irá guiá-lo sobre como aproveitar esses modelos usando a API da OpenAI dentro do seu projeto web Django. Você aprenderá como chamar a API de Completamento de Conversa usando diferentes parâmetros e como formatar e utilizar suas respostas.

Ao final deste tutorial, você terá criado um endpoint Django que, quando chamado, envia uma solicitação para a OpenAI para construir uma história curta usando as palavras fornecidas e retorna sua resposta.

Pré-requisitos

Para completar este tutorial, você precisará:

1. Um projeto Django existente. Se estiver começando do zero, você pode configurar um projeto Django seguindo o tutorial como configurar um ambiente de desenvolvimento Django.

2. Uma conta OpenAI: Acesse o site da plataforma OpenAI e procure pelo botão ‘Inscrever-se’. Após se inscrever, você deve verificar seu endereço de e-mail e inserir informações pessoais.

3. Uma chave de API da OpenAI: Depois de configurar sua conta, faça login e acesse a seção de Chaves de API do seu painel. Clique em ‘Criar nova chave secreta’. Sua chave de API será gerada e terá um formato semelhante a sk-abcdefghijklmnop. Certifique-se de salvar esta chave em um local seguro, pois você não poderá visualizá-la novamente.

4. O pacote Python da OpenAI: Se você seguiu o tutorial no primeiro pré-requisito, você já deve ter um ambiente virtual chamado env ativo dentro de um diretório chamado django-apps. Verifique se o seu ambiente virtual está ativo confirmando que seu nome aparece entre parênteses no início do seu prompt de terminal. Se não estiver ativo, você pode ativá-lo manualmente executando o comando:

sammy@ubuntu:$ .env/bin/activate

No seu terminal a partir do diretório django-apps. Uma vez que seu ambiente esteja ativo, execute o seguinte para instalar o pacote Python da OpenAI:

(env)sammy@ubuntu:$ pip install openai

Passo 1 — Fazendo chamadas para a OpenAI

Nesta etapa, você adicionará sua chave de API da OpenAI ao cliente da OpenAI e fará uma chamada de API simples para a API de Completamento de Conversa. Você também examinará a resposta que recebe da API.

Para começar, abra seu interpretador Python:

(env)sammy@ubuntu:$ python

Primeiro, importe o cliente da OpenAI e adicione sua chave de API ao cliente:

from openai import OpenAI
client = OpenAI(api_key="your-api-key")

Substitua "sua-chave-de-api" pela chave de API real que você obteve na plataforma da OpenAI.

Agora, vamos fazer uma chamada de API para a API de Completamento de Conversa. Use o método chat.completions.create():

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "count 1 to 10"}])

No código acima, especificamos o modelo a ser usado como gpt-3.5-turbo, adicionamos um único objeto de mensagem contendo o papel usuário (outras opções são sistema e assistente) e o conteúdo / prompt contar de 1 a 10.

Para ver a resposta da chamada de API, você pode imprimir a mensagem de resposta, que deve conter os números de 1 a 10 em uma pequena lista agradável:

print(response.choices[0].message.content)

Saída:

Output
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Parabéns! Você fez com sucesso uma chamada de API simples para a OpenAI e obteve uma resposta. Vamos formatar e utilizar a resposta da API para criar uma história curta nos próximos passos.

Passo 2 — Trabalhando com parâmetros

Agora que você fez com sucesso uma chamada simples de API para a API ChatCompletion, vamos explorar como trabalhar com parâmetros para personalizar o comportamento do modelo. Existem vários parâmetros disponíveis que permitem controlar a geração de texto. Vamos dar uma olhada nos três abaixo.

1. Temperatura: O parâmetro de temperatura determina o quão aleatório é o conteúdo gerado. Um valor de temperatura mais alto, como 0.8, fornecerá respostas mais diversas e criativas, enquanto um valor de temperatura mais baixo, como 0.1, produzirá respostas mais similares. Por exemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Vamos tentar temperatura=0.1 novamente para ver o texto recém-gerado:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

O texto acabou sendo o mesmo. Agora, vamos tentar temperatura=0.8 duas vezes:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)
cat, apple, guitar, sky, book
response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)

Output
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

2. Máximo de tokens: Isso permite limitar o comprimento do texto gerado. Definir um valor específico garante que a resposta não exceda um certo número de tokens. Tokens são proporcionais ao número de palavras na resposta. Por exemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=10)
print(response.choices[0].message.content)

Output
1. Apple
2. Car

Alterando o valor para 20:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=20)
print(response.choices[0].message.content)

Output
1. Apple
2. Car
3. Music
4. Ocean
5. Love

3. Stream: Isso determina se as respostas devem ser transmitidas ou retornadas. Quando definido como True, a resposta da API será transmitida, o que significa que você receberá a saída em partes conforme ela é gerada. Isso é útil para conversas longas ou aplicativos em tempo real. Para habilitar o streaming, adicione o parâmetro stream com um valor de True à chamada da API. Por exemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], stream=True)
collected_messages = []
for chunk in response:
...   chunk_message = chunk.choices[0].delta.content
...   if chunk_message is not None:
...     collected_messages.append(chunk_message)
print(collected_messages)

Output
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

No código acima, a variável chunk_message contém o conteúdo da mensagem em cada fragmento retornado pela API. Antes de adicioná-lo à lista collected_messages, verificamos se o fragmento é None, pois o conteúdo do último fragmento geralmente é None.

Utilizando esses parâmetros, você pode personalizar o comportamento do modelo e controlar as respostas geradas para melhor atender à sua aplicação ou projeto. Experimente diferentes valores para obter os resultados desejados.

Na próxima etapa, forneceremos algum contexto ao modelo na forma de um prompt de sistema.

Etapa 3 — Criando um prompt de sistema

Nesta etapa, combinaremos todas as informações que aprendemos e criaremos um prompt de sistema que fornece contexto ao modelo GPT, informando seu propósito e especificando suas regras.

Primeiro, vamos criar um módulo Python contendo uma função para lidar com essa tarefa. Feche o interpretador e crie um novo arquivo chamado story_generator.py no diretório do seu projeto Django.

(env)sammy@ubuntu:$ touch ~/my_blog_app/blog/blogsite/story_generator.py

Em seguida, você pode adicionar a chave da API do OpenAI às suas variáveis de ambiente para não adicioná-la diretamente ao arquivo Python:

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

Abra story_generator.py e dentro dele, crie um cliente openai e defina uma função chamada generate_story que recebe uma coleção de palavras como entrada:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Chame a API da OpenAI para gerar a história
    response = get_short_story(words)
    # Formate e retorne a resposta
    return format_response(response)

Nesta função, chamamos uma função separada, get_short_story, para fazer a chamada à API da OpenAI para a história e então outra função, format_response, para formatar a resposta da API.

Agora, vamos focar na função get_short_story. Adicione o seguinte ao final do seu arquivo story_generator.py:

def get_short_story(words):
    # Construa o prompt do sistema
    system_prompt = f"""You are a short story generator.
    Write a short story using the following words: {words}.
    Do not go beyond one paragraph."""
    # Faça a chamada à API
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{
            "role": "user",
            "content": system_prompt
        }],
        temperature=0.8,
        max_tokens=1000
    )

    # Retorne a resposta da API
    return response

Nesta função, primeiro configuramos o prompt do sistema, que informa ao modelo sobre a tarefa que ele precisa realizar e especifica o tamanho que a história deve ter. Em seguida, passamos este prompt do sistema para a API de Completude de Chat e retornamos sua resposta.

Finalmente, podemos implementar a função format_response. Adicione o seguinte ao final do seu arquivo story_generator.py:

def format_response(response):
    # Extraia a história gerada da resposta
    story = response.choices[0].message.content
    # Remova qualquer texto ou formatação indesejados
    story = story.strip()
    # Retorne a história formatada
    return story

Agora você pode testar essas funções chamando a função generate_story, passando uma coleção de palavras como argumento, e imprimindo sua resposta. Adicione o seguinte ao final do seu arquivo story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Agora salve e saia do arquivo. Execute o script para ver a história gerada:

(env) sammy@ubuntu:$ python ~/my_blog_app/blog/blogsite/story_generator.py

Saída:

In a cozy corner of a sunlit room, a fluffy cat named Whiskers lounged lazily next to a towering bookshelf. Amongst the rows of books, a curious computer hummed softly. As the sun streamed through the window, casting a warm glow, Whiskers noticed a small water stain on the shelf. Intrigued, the cat pawed at the book closest to the mark. As if guided by fate, the book opened to reveal a hidden compartment containing a glittering diamond necklace. With the secret now unveiled, Whiskers embarked on an unexpected adventure, where the sun, water, and the power of knowledge merged into a thrilling tale of mystery and discovery.

Bastante interessante! Vamos excluir a linha com a instrução print, já que chamaremos a função generate_story a partir de uma view do Django. Remova a linha destacada do seu arquivo story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Sinta-se à vontade para experimentar com a sugestão do sistema e adicionar mais contexto e regras para melhorar as histórias geradas.

Continue para o próximo passo para integrar o módulo story_generator ao seu projeto Django.

Passo 4 – Integração com uma visualização do back-end:

Você deve criar uma visualização Django e uma rota de URL para integrar o módulo story_generator ao seu projeto Django. Na visualização, você irá extrair as palavras esperadas da requisição, chamar a função generate_story e retornar a resposta.

Primeiro, abra o arquivo views.py no diretório do seu aplicativo Django. Importe os módulos necessários e adicione uma função de visualização chamada generate_story_from_words:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # Extrair as palavras esperadas da requisição
    story = generate_story(words) # Chamar a função generate_story com as palavras extraídas
    return JsonResponse({'story': story}) # Retornar a história como uma resposta JSON

Em seguida, abra o arquivo urls.py e adicione um padrão de URL para a visualização generate_story_from_words:

urlpatterns = [
    # Outros padrões de URL...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

Agora, você pode solicitar o endpoint /generate-story/. Por exemplo, para testar usando curl, você pode fazer uma solicitação GET para o endpoint com as palavras esperadas como parâmetro de consulta. Abra seu terminal e execute o seguinte comando:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words=cat,book,computer,sun,water"

Certifique-se de substituir "http://seu_domínio" pelo domínio real onde seu projeto Django está hospedado. As palavras "gato,livro,computador,sol,água" representam as palavras esperadas com as quais você deseja gerar uma história. Você pode alterá-las para quaisquer palavras de sua preferência.

Após executar o comando, você deverá ver a resposta do servidor, que conterá a história gerada:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words="cat,book,computer,sun,water"

Saída:

{"story": "Once upon a time, in a cozy little cottage nestled amidst a dense forest, a curious cat named Whiskers sat by the window, basking in the warm rays of the sun. As Whiskers lazily flicked his tail, his eyes caught sight of a dusty book lying on a nearby shelf. Intrigued, he carefully jumped onto the shelf, causing a cascade of books to tumble down, one opening up to reveal a hidden compartment. Inside, Whiskers discovered an ancient computer, its screen flickering to life as he brushed against the power button. Mesmerized by the glowing screen, Whiskers ventured into a world of virtual landscapes, where he roamed freely, chasing digital fish and pausing to admire breathtaking waterfalls. Lost in this newfound adventure, Whiskers discovered the wonders of both the tangible and virtual worlds, realizing that true exploration knows no bounds."}

Conclusão

Após completar este tutorial, você aprendeu como integrar os modelos da OpenAI GPT em seu projeto Django usando a API da OpenAI. Você fez chamadas para a API de CompletarConversa, personalizou o comportamento do modelo trabalhando com parâmetros como temperatura e máximo de tokens, e criou um prompt de sistema para fornecer contexto ao modelo. Você também integrou o módulo story_generator em seu projeto Django. Agora, você pode gerar histórias curtas solicitando o endpoint /generate-story/ com as palavras esperadas como parâmetro de consulta.

Para aprimorar ainda mais seu projeto Django, você pode explorar funcionalidades adicionais da API da OpenAI e experimentar com prompts e parâmetros de sistema diferentes para gerar histórias únicas e criativas.