API Python OpenAI: Use o SDK OpenAI com nosso modelo

Para código de API Python, você não precisa de biblioteca especial. O pacote openai oficial funciona neste serviço após definir uma base URL e chave diferentes, com o model ID uncensored. Abaixo está um guia completo com exemplos prontos para copiar.
Pontos principais
- Instale openai e passe base_url e api_key ao cliente; nada no seu código muda.
- Streaming, modo JSON e chamada de funções funcionam pelos mesmos métodos do SDK.
- Capture RateLimitError e tente novamente; os limites são 300 requisições por minuto e 8 simultâneas com uma chave completa.
- O custo é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, cobrado apenas para requisições bem-sucedidas.
Instale e faça a primeira chamada
Você precisa do Python 3.9 ou mais recente e do SDK oficial. Crie uma chave de API primeiro na página de chaves; novas contas podem resgatar $0,50 de crédito de teste com um clique, sem cartão.
pip install openai
export API_KEY="your-key-here"
Agora o script mínimo funcional. O cliente recebe a base URL e a chave; a requisição usa o model ID uncensored.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.aiapisource.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise writing assistant."},
{"role": "user", "content": "Give me three opening lines for a mystery novel."},
],
temperature=0.8,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Essa é a integração completa. O serviço implementa POST /v1/chat/completions e GET /v1/models, cobrindo o que a maioria dos scripts usa. É um modelo de texto apenas, então endpoints de imagem, áudio e embeddings não estão disponíveis.
O que é e o que não é
O SDK é da OpenAI, mas o endpoint aqui não é da OpenAI. É um modelo de pesos abertos hospedado, operado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto legal. Não há roteamento para GPT ou modelo de outro fornecedor. É por isso que você altera a base URL: você está falando com um servidor diferente que aceita o mesmo formato de requisição.
Se você está migrando um projeto existente, busque por OpenAI( e por nomes de modelos codificados. Esses são os únicos dois lugares que precisam de edição. A lista de verificação de produção da API GPT neste site abrange hábitos que se aplicam a qualquer endpoint no formato OpenAI, como timeouts e retentativas.
Faça streaming da resposta
Para interfaces de chat, você quer tokens conforme são produzidos. Defina stream=True e itere. Solicite o uso no final se quiser números de faturamento:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about a night train."}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
A validação em chunk.choices é importante: o último chunk pode conter o uso e nenhum item em choices. Além disso, uma requisição em streaming ocupa um dos seus slots de concorrência até o fim do streaming, então sempre leia até o final ou feche-a.
Modo JSON
Quando seu código precisa analisar a resposta, ative o modo JSON e descreva as chaves no prompt:
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "user", "content": "Return JSON with keys name (string) and traits (list of 3 strings) for a fictional ship captain."}
],
)
character = json.loads(resp.choices[0].message.content)
print(character["name"], character["traits"])
JSON válido é o resultado provável, não uma promessa do seu schema exato, então verifique as chaves e tente novamente em caso de falha.
Chamada de funções
Descreva funções em tools, execute o que o modelo pedir e envie o resultado de volta com role: "tool":
import json
tools = [{
"type": "function",
"function": {
"name": "roll_dice",
"description": "Roll a die with the given number of sides",
"parameters": {
"type": "object",
"properties": {"sides": {"type": "integer"}},
"required": ["sides"],
},
},
}]
messages = [{"role": "user", "content": "Roll a 20-sided die for my character."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"value": 14, "sides": args["sides"]} # replace with real logic
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)
Você pode passar tool_choice para forçar uma função. Os argumentos vêm como string JSON, então sempre execute-os via json.loads e valide antes de usar.
Erros, tentativas e async
O SDK tenta novamente algumas falhas automaticamente, e você pode definir a contagem com max_retries. Para limites de taxa, capture a exceção e aguarde. A API retorna HTTP 429 com o código rate_limited quando você ultrapassa o limite por minuto, com concurrency quando muitas requisições rodam simultaneamente, e com o cabeçalho Retry-After: 5 em sobrecarga temporária.
import time
from openai import RateLimitError
def ask(prompt, tries=4):
for attempt in range(tries):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5 * (attempt + 1))
raise RuntimeError("Still rate limited after retries")
Para lotes, use o cliente assíncrono e limite a paralelização abaixo do seu limite. Uma chave completa permite 8 requisições simultâneas e 300 por minuto; uma chave de teste permite 2 e 60.
import asyncio, os
from openai import AsyncOpenAI
aclient = AsyncOpenAI(base_url="https://api.aiapisource.com/v1", api_key=os.environ["API_KEY"])
sem = asyncio.Semaphore(6)
async def one(prompt):
async with sem:
r = await aclient.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
async def main():
prompts = [f"Write a tagline for product number {i}." for i in range(20)]
results = await asyncio.gather(*(one(p) for p in prompts))
print(len(results), "done")
asyncio.run(main())
Usar 6 dos 8 slots deixa espaço para outro tráfego na mesma chave.
Mantenha a conversa
A API é sem estado. Ela não lembra nada entre chamadas, então um chat é apenas a lista de mensagens que você envia a cada vez. Adicione a resposta à lista e envie a lista inteira novamente:
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
r = client.chat.completions.create(model="uncensored", messages=history)
reply = r.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a short story."))
print(chat("Make it darker and set it in a harbour town."))
Cada chamada envia mais tokens que a anterior, e tokens de entrada são cobrados em cada chamada. Quando a lista fica longa, remova as rodadas mais antigas ou substitua-as por um resumo curto. A janela de contexto é de 100.000 tokens para prompt mais conclusão, o que é muito, mas um histórico longo torna cada requisição mais cara e lenta para iniciar.
Configurações de amostragem são repassadas sem alteração: temperature, top_p, stop, seed e as penalidades de frequência e presença. Defina seed e uma temperatura baixa quando quiser execuções de teste repetíveis.
Estime o custo antes de uma execução grande
O faturamento é por token a partir do crédito pré-pago: $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída. Requisições falhas ou recusadas não são cobradas, e o crédito nunca expira. Pegue um lote de 10.000 requisições com 1.500 tokens de entrada e 400 tokens de saída cada. Entrada é 15.000.000 de tokens, que é 15 x $0,15 = $2,25. Saída é 4.000.000 de tokens, que é 4 x $0,50 = $2,00. O lote custa $4,25.
Os cabeçalhos de resposta incluem X-Balance-USD, então você pode ler seu saldo restante no código através de client.chat.completions.with_raw_response.create(...). Recargas são qualquer valor inteiro de $20 a $500, com +5% a partir de $50, +10% a partir de $100 e +15% a partir de $200. A página de preços lista opções de pagamento, e o quickstart lista todos os parâmetros suportados, incluindo stop, seed e as penalidades.
Mais guias
Perguntas e respostas
Posso usar o pacote Python oficial da OpenAI com esta API?
Sim. Instale openai, defina base_url para o endpoint do serviço e api_key para sua chave, e chame chat.completions.create com o modelo uncensored.
Preciso de uma biblioteca diferente para streaming ou ferramentas?
Não. Streaming, modo JSON e chamada de funções funcionam pelos mesmos métodos do SDK, com os parâmetros usuais.
Este é o modelo da OpenAI?
Não. É um modelo de pesos abertos operado por um provedor independente. O formato da requisição é o mesmo, por isso o SDK funciona.
Meus prompts treinam o modelo?
Não. Prompts enviados pela API não são usados para treinamento.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a base URL. Essa é toda a configuração.