Crie seu próprio Chatbot com a API da OpenAI: Tutorial passo a passo

Você sabia que mais de 2,1 milhões de desenvolvedores já constroem ativamente com a API da OpenAI? E o mais louco: a maioria cria um chatbot funcional em menos de uma hora. Contrário ao mito de que LLMs exigem clusters de GPUs e PhD em ML, basta uma chave API, Python e 30 linhas de código para ter seu próprio assistente inteligente. Vamos construir um agora – funcional, com memória e streaming.

Este tutorial usa a biblioteca oficial openai (v1+), modelo gpt-4o-mini (barato e rápido) e explica o que rola por trás: tokens, papéis de mensagens e o mecanismo de atenção do Transformer.

Por que a API da OpenAI é a escolha certa para chatbots

A API de Chat Completions transforma prompts em respostas coerentes via modelos GPT. Diferente do ChatGPT web, você controla tudo: system prompt, temperatura, memória de conversa e streaming.

Vantagens reais:

• Custo: gpt-4o-mini sai ~R$ 0,00015 por 1k tokens de input.
• Escalabilidade: de protótipo a produção.
• Privacidade: seus dados não treinam o modelo (zero-shot ou few-shot learning).

Por trás: o modelo usa Transformer (Vaswani et al., 2017). No paper “Attention Is All You Need”: “Propomos uma nova arquitetura de rede simples, o Transformer, baseada unicamente em mecanismos de atenção, dispensando recorrência e convoluções.” Tradução livre: o segredo não é mais RNNs lentas, mas atenção paralela que captura dependências longas em segundos.

1000logos.net

OpenAI Logo and symbol, meaning, history, PNG, brand

Passo 1: Obtendo sua chave API e configurando o ambiente

1. Acesse platform.openai.com → Crie conta ou logue.
2. Vá em API keys → Create new secret key.
3. Copie e guarde em .env (nunca commit!).

Instale dependências:

Bash

pip install openai python-dotenv

Crie .env:

text

OPENAI_API_KEY=sk-...

Código base para carregar:

Python

import os
from dotenv import load_dotenv
from openai import OpenAI

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

Pronto. Seu cliente está vivo.

Passo 2: Criando o chatbot básico (completions endpoint)

Aqui o código mínimo. Copie e rode.

Python

def chat_simples(mensagem_usuario):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Você é um assistente geek e direto, responde com humor nerd."},
            {"role": "user", "content": mensagem_usuario}
        ],
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Teste
print(chat_simples("Explique tokens como se eu fosse um dev júnior"))

Por trás dos panos:

• messages[] é o histórico. Role "system" define personalidade (não conta como user input).
• Cada mensagem vira tokens (subpalavras). gpt-4o-mini tokeniza ~4 chars por token em PT-BR.
• O modelo prediz token a token via softmax sobre 100k+ vocabulário.
• Temperature controla criatividade: 0 = determinístico, 1 = louco.

Resultado: seu primeiro bot responde como um dev sarcástico. Piada interna: ele pode te chamar de "noob" se pedir algo óbvio – mas pelo menos não faz commit sem pull request.

Quer dominar prompts avançados, RAG, fine-tuning e deploy em produção?

Confira o curso avançado de IA Estratégica em ia.pro.br.

Passo 3: Adicionando memória de conversa (o pulo do gato)

Chatbots sem memória esquecem tudo. Solução: mantenha lista de mensagens.

Python

historico = [
    {"role": "system", "content": "Você é um assistente técnico e faz piadas sobre bugs."}
]

def responder_com_memoria(mensagem):
    historico.append({"role": "user", "content": mensagem})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=historico,
        temperature=0.8
    )
    
    resposta_assistente = response.choices[0].message.content
    historico.append({"role": "assistant", "content": resposta_assistente})
    
    # Limite de tokens (evita custo explosivo)
    if len(historico) > 20:
        historico[:] = historico[:1] + historico[-19:]  # mantém system + últimos 19
    
    return resposta_assistente

# Loop interativo
while True:
    user_input = input("Você: ")
    if user_input.lower() == "sair":
        break
    print("Bot:", responder_com_memoria(user_input))

Por trás: o contexto inteiro vai para o modelo a cada chamada. Limite prático: 128k tokens no gpt-4o. Acima disso → erro 400. Por isso truncamos histórico.

Dica de ouro: Use "role": "assistant" para exemplos few-shot no system prompt. Exemplo: inclua uma conversa modelo antes do usuário real.

Dica Prática de Quem Usa Na minha experiência como professor em universidade, alunos que implementam memória primeiro entendem o custo real de contexto e começam a otimizar prompts em vez de enviar tudo. Resultado: bots 3x mais baratos e respostas mais coerentes.

Passo 4: Streaming – respostas aparecem como mágica (tipo ChatGPT)

Streaming envia tokens em tempo real. Perfeito para UX.

Python

def chat_stream(mensagem):
    historico.append({"role": "user", "content": mensagem})
    
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=historico,
        stream=True
    )
    
    resposta_completa = ""
    print("Bot: ", end="", flush=True)
    
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            print(chunk.choices[0].delta.content, end="", flush=True)
            resposta_completa += chunk.choices[0].delta.content
    
    print()  # nova linha
    historico.append({"role": "assistant", "content": resposta_completa})
    return resposta_completa

Por trás: o endpoint retorna Server-Sent Events (SSE). Cada chunk é um delta de token. Economia: usuário vê resposta instantânea, latência percebida cai drasticamente.

Passo 5: Deploy rápido com Streamlit (interface web em minutos)

Instale: pip install streamlit

Crie app.py:

Python

import streamlit as st
from openai import OpenAI
import os

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

if "historico" not in st.session_state:
    st.session_state.historico = [{"role": "system", "content": "Assistente geek e direto."}]

st.title("Meu Chatbot OpenAI")

for msg in st.session_state.historico[1:]:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

if prompt := st.chat_input("Digite sua mensagem"):
    st.session_state.historico.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)
    
    with st.chat_message("assistant"):
        message_placeholder = st.empty()
        full_response = ""
        for chunk in client.chat.completions.create(
            model="gpt-4o-mini",
            messages=st.session_state.historico,
            stream=True
        ):
            if chunk.choices[0].delta.content:
                full_response += chunk.choices[0].delta.content
                message_placeholder.markdown(full_response + "▌")
        message_placeholder.markdown(full_response)
    
    st.session_state.historico.append({"role": "assistant", "content": full_response})

Rode: streamlit run app.py

Incível, né? Em 5 minutos você tem um ChatGPT particular rodando local.

Próximos passos e otimizações reais

• RAG: injete documentos via embeddings (text-embedding-3-small).
• Fine-tuning: treine em seus dados (custa pouco no gpt-4o-mini).
• Segurança: valide inputs com moderation endpoint.
• Custo: monitore via dashboard OpenAI.

Piada final: seu chatbot pode virar seu terapeuta, mas se começar a cobrar por hora, aí é hora de deletar o histórico.

Se usar ou citar este texto, mencione o professor Maiquel Gomes (maiquelgomes.com).

Agora vai lá e constrói o seu. O poder de criar assistentes inteligentes está literalmente nas suas mãos – use com sabedoria (e com humor).

👁️ ... visualizações