PT ▾

API Python OpenAI: Use o SDK OpenAI com nosso modelo

Cabo em formato de cobra conectado a um servidor com balões de chat, representando Python chamando uma API

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.

Atualizado

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.

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.

Obter chave de API