API de Deep Learning para Texto: Crie um Chatbot Rápido
Uma API de deep learning para texto permite criar um chatbot funcional em cerca de quinze minutos, porque o modelo faz o trabalho de linguagem e você apenas gerencia as mensagens. Abaixo está um chatbot Python completo com histórico, streaming e limite de tokens, usando um endpoint compatível com OpenAI.

Resumo
- Um chatbot é um loop que adiciona mensagens e reenvia o histórico a cada turno.
- O custo de entrada cresce a cada turno, então reduza ou resuma as mensagens antigas.
- O streaming fornece o uso no final, que você pode usar para rastrear os gastos.
- Remover turnos antigos reduz os tokens de entrada de um chat de 50 turnos em cerca de 62%.
O que você precisa
O modelo é hospedado, então não há nada para treinar nem GPU para alugar. Você precisa do Python 3.9 ou mais recente, do SDK da OpenAI (pip install openai) e de uma chave. Cadastre-se, resgate o crédito de teste de $0,50 na página da chave de API e mantenha a chave em uma variável de ambiente:
# endpoint https://api.deepapi.cc/v1, model uncensored
export DEEPAPI_KEY="paste-your-key-here"
O endpoint é https://api.deepapi.cc/v1 e o ID do modelo é uncensored. É uma API compatível com OpenAI, apenas texto, que serve um único modelo de peso aberto operado por um provedor independente, então o código é o mesmo para qualquer cliente OpenAI. Não há embeddings, imagens ou áudio aqui, apenas texto de entrada e texto de saída.
A ideia central: o modelo não tem memória
Cada requisição é independente. A API não lembra o que você disse há um minuto. Para ter uma conversa, você envia toda a conversa toda vez: uma mensagem de sistema, seguida de mensagens alternadas de usuário e assistente, terminando com a nova mensagem do usuário. A resposta é adicionada à lista, e o próximo turno envia a lista maior.
Esse único fato explica a maioria das escolhas de design em um chatbot. É por isso que chats longos custam mais por turno, por que você precisa de um plano para mensagens antigas e por que a janela de contexto importa. Este serviço tem 100,000 tokens no total para prompt mais conclusão.
Um chatbot em 40 linhas
Esta versão transmite a resposta, mantém o histórico e imprime o uso de tokens após cada turno.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.deepapi.cc/v1",
api_key=os.environ["DEEPAPI_KEY"],
)
SYSTEM = {"role": "system", "content": "You are a friendly, concise assistant."}
history = [] # user and assistant messages only
MAX_TURNS = 10 # keep about the last 10 exchanges
def reply(user_text):
history.append({"role": "user", "content": user_text})
window = history[-MAX_TURNS * 2:]
stream = client.chat.completions.create(
model="uncensored",
messages=[SYSTEM] + window,
stream=True,
temperature=0.7,
)
text, usage = "", None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
print(piece, end="", flush=True)
text += piece
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
history.append({"role": "assistant", "content": text})
return usage
while True:
user = input("you> ").strip()
if user in {"", "exit", "quit"}:
break
u = reply(user)
if u:
cost = u.prompt_tokens * 0.15 / 1e6 + u.completion_tokens * 0.50 / 1e6
print(f"[{u.prompt_tokens} in, {u.completion_tokens} out, ${cost:.5f}]")
Execute-o, converse por alguns turnos e observe o número "in" aumentar. A resposta transmitida relata o uso no final, então o valor é exato e não precisa de estimativa.
Orçamento de tokens: por que a redução importa
Suponha que o prompt do sistema tenha 200 tokens e cada turno adicione 100 tokens do usuário e 250 do assistente. Sem podar, o turno k envia 200 + 350 x (k - 1) + 100 tokens de entrada. Em uma conversa de 50 turnos:
- Total de entrada: 50 x 300 + 350 x (0 + 1 + ... + 49) = 15.000 + 350 x 1.225 = 443.750 tokens
- Total de saída: 50 x 250 = 12.500 tokens
- Custo: 443.750 x $0,15 / 1M = $0,0666, mais 12.500 x $0,50 / 1M = $0,0063, o que é cerca de $0,073
Agora mantenha apenas as últimas 10 trocas. As primeiras 10 rodadas custam 18.750 tokens de entrada, e cada uma das 40 restantes envia 3.700, totalizando 148.000. O total é de 166.750 tokens de entrada, cerca de 62% a menos que antes, por um custo de $0,0250 na entrada.
A economia é mais significativa com mensagens mais longas ou mais usuários. Um chatbot que atende milhares de conversas por dia vê a diferença no saldo.
Melhor que remover: resumir
Remover turnos antigos perde fatos que o usuário mencionou no início, como um nome ou uma preferência. Uma solução comum é pedir ao modelo um resumo curto quando o histórico cresce e carregar o resumo em vez das mensagens antigas.
# uses the client from above (base_url https://api.deepapi.cc/v1)
def compress(history, keep=6):
if len(history) <= keep * 2:
return history
old, recent = history[:-keep * 2], history[-keep * 2:]
summary = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Summarise this conversation in under 120 words. Keep names, facts and open questions."},
{"role": "user", "content": "\n".join(m["role"] + ": " + m["content"] for m in old)},
],
).choices[0].message.content
return [{"role": "user", "content": "Summary of earlier chat: " + summary}] + recent
Chame-o de vez em quando, por exemplo quando o histórico passar de 20 mensagens: history = compress(history). A chamada de resumo custa alguns milhares de tokens uma vez, e cada rodada posterior fica mais barata. Defina também um orçamento aproximado. Uma contagem de caracteres dividida por quatro é uma estimativa de token decente para inglês, e o bloco de uso fornece o número real após cada chamada.
Testando o bot antes que usuários reais o vejam
Um chatbot que funciona para três mensagens amigáveis ainda pode falhar em produção. Execute esta breve lista de verificação primeiro.
- Respostas longas. Peça uma história de 1.000 palavras e confirme se o stream não trava e se o texto completo chega em
history. - Entrada vazia e enorme. Envie uma linha vazia e um muro de texto colado. O loop acima ignora entrada vazia, mas você também deve limitar o comprimento de uma mensagem antes que ela alcance a API.
- Conexão interrompida. Interrompa a rede no meio de um streaming. A resposta parcial não deve ser salva como se fosse completa, então anexe a
historyapenas após o loop terminar sem exceção. - Memória de fatos iniciais. Diga ao bot seu nome na primeira rodada e pergunte por ele na 15ª. Se falhar, mude da poda simples para a abordagem de resumo.
- Custo por conversa. Execute um chat de 20 rodadas e some os custos impressos. Multiplique pelo número de conversas que você espera por dia.
Mantenha o prompt do sistema curto e específico. Indique o papel do bot, o tom e quaisquer regras de formato em algumas linhas e teste alterações uma de cada vez. Cada palavra no prompt do sistema é enviada novamente a cada rodada, então um prompt de 200 tokens custa cerca de $0,00003 por solicitação na entrada, o que é pouco, mas se acumula em milhares de solicitações.
Lidando com limites e erros
Um chatbot de usuário único raramente atinge os limites, mas um implantado sim. Uma chave completa permite 8 requisições simultâneas e 300 por minuto; uma chave de teste, 2 e 60. Ao ultrapassar um limite, a API retorna HTTP 429 com o código rate_limited ou concurrency. Sobrecarga temporária também retorna 429 com Retry-After: 5. Como uma requisição streaming mantém seu slot até o fim, um chatbot web com muitos streams abertos deve enfileirar ou rejeitar novos. Requisições falhas ou recusadas não são cobradas, então tentar novamente não custa nada a mais.
Outros controles úteis: temperature e top_p para variedade, stop para finais personalizados e seed para execuções de teste repetíveis. O modo JSON e a chamada de funções estão disponíveis para respostas estruturadas e uso de funções. A documentação cobre todos eles.
Colocando em um site
O mesmo padrão funciona por trás de um endpoint web. Mantenha a chave de API no servidor, nunca no JavaScript do navegador, porque qualquer pessoa pode ler o código do cliente. O navegador envia a nova mensagem do usuário para o seu servidor, seu servidor carrega o histórico desse usuário, chama a API e transmite a resposta de volta.
Três detalhes evitam problemas. Armazene o histórico por sessão para que os usuários não vejam as conversas uns dos outros. Limite o comprimento de uma mensagem do usuário antes de encaminhá-la, já que um romance colado custa dinheiro real. E limite os streams simultâneos por chave à concorrência do seu plano: com uma chave completa isso é 8 simultâneas, e uma nona deve esperar em uma fila. Para uma ferramenta interna pequena, isso leva algumas dezenas de linhas, e a URL base e a chave são as únicas partes específicas do provedor.
Para onde ir a partir daqui
Envolva reply em um pequeno servidor web, armazene o histórico por usuário em um banco de dados e adicione uma persona ao prompt do sistema. Se quiser comparar provedores antes de se comprometer, o artigo sobre alternativas à API DeepSeek lista critérios. Para custos na sua própria escala, consulte a página de preços. Recargas variam de $20 a $500, apenas em cripto, com bônus a partir de $50, e o crédito nunca expira.
Mais guias
Perguntas frequentes
Preciso treinar um modelo para usar uma API de aprendizado profundo para texto?
Não. O modelo já está treinado e hospedado. Você envia mensagens via HTTPS e recebe texto de volta.
A API lembra as mensagens anteriores?
Não. Cada requisição é independente, então seu código deve reenviar o histórico da conversa a cada turno.
Quantos tokens uma conversa pode usar?
A janela de contexto é de 100.000 tokens para prompt mais conclusão. Reduza ou resuma antes de chegar perto disso.
Posso usar isso com JavaScript?
Sim. Use o SDK Node da OpenAI com baseURL definido para https://api.deepapi.cc/v1 e o modelo uncensored, ou chame o endpoint com fetch.
Obtenha sua chave de API instantaneamente
Cadastre-se, copie sua chave, atualize sua URL base. É só isso.