Como Integrar Modelos OpenAI GPT em seu Projeto Django

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

Introdução

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

Esses modelos GPT são geralmente utilizados por meio do ChatGPT, um chatbot lançado pela OpenAI, ou por meio de APIs e bibliotecas que fornecem 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 Chat usando diferentes parâmetros e como formatar e utilizar suas respostas.

Ao final deste tutorial, você terá criado um endpoint do 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 concluir 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 ‘Cadastre-se’. Após se cadastrar, você deve verificar seu endereço de e-mail e fornecer 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á vê-la novamente.

4. O pacote Python da OpenAI: Se você seguiu o tutorial no primeiro pré-requisito, você deverá ter um ambiente virtual chamado env ativo dentro de um diretório chamado django-apps. Verifique se o seu ambiente virtual está ativo confirmado que o nome dele aparece entre parênteses no início do prompt do seu 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. Depois que o seu ambiente estiver ativo, execute o seguinte para instalar o pacote Python da OpenAI:

(env)sammy@ubuntu:$ pip install openai

Passo 1 — Fazendo chamadas para a OpenAI

Neste passo, você irá adicionar sua chave de API da OpenAI ao cliente da OpenAI e fazer uma chamada de API simples para a API de Completude 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 da plataforma OpenAI.

Agora, vamos fazer uma chamada de API para a API de Completude 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 utilizado como gpt-3.5-turbo, adicionamos um único objeto 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 lista bem pequena:

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. Formataremos e utilizaremos a resposta da API para criar uma pequena história nos próximos passos.

Passo 2 — Trabalhando com parâmetros

Agora que você fez com sucesso uma chamada de API simples para a API de Completude de Chat, 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, dará respostas mais diversas e criativas, enquanto um valor de temperatura mais baixo, como 0.1, produzirá respostas mais semelhantes. 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 temperature=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 temperature=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. Os 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. Fluxo: 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 pedaços conforme ela é gerada. Isso é útil para conversas longas ou aplicações em tempo real. Para habilitar o streaming, adicione o parâmetro stream com um valor de True na 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, já que 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 o arquivo story_generator.py e dentro dele, crie um cliente do OpenAI e defina uma função chamada generate_story que receba 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 depois outra função, format_response, para formatar a resposta da API.

Agora, vamos nos concentrar 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 precisa executar e especifica o tamanho que a história deve ter. Em seguida, passamos este prompt do sistema para a API de Completude de Conversa e retornamos sua resposta.

Por fim, 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 estas 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 vamos chamar a função generate_story a partir de uma visualização 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 o prompt 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 de back-end:

Você deve criar uma visualização do Django e uma rota de URL para integrar o módulo story_generator ao seu projeto Django. Na visualização, você extrairá as palavras esperadas da solicitaçã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 o 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 qualquer palavra que preferir.

Após executar o comando, você deve 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

Depois de concluir este tutorial, você aprendeu como integrar modelos OpenAI GPT em seu projeto Django usando a API OpenAI. Você fez chamadas para a API de Completamento de Chat, 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 contos curtos 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 OpenAI e experimentar com diferentes prompts de sistema e parâmetros para gerar histórias únicas e criativas.