PT ▾
Obter chave de API

uncensoredqwen.comGuia

SDK da API Qwen: use o SDK Python da OpenAI

A API não requer um SDK dedicado do Qwen. Ela utiliza o formato de rede OpenAI, portanto, os SDKs oficiais da OpenAI funcionam assim que você altera a URL base e a chave. Esta página mostra a instalação, a primeira chamada, streaming, ferramentas e tratamento de erros.

Atualizado

Adaptador isométrico conectando um soquete SDK padrão a um pequeno servidor, mostrando a reutilização do SDK OpenAI

Por que o SDK OpenAI cobre o que você precisa

Quando as pessoas procuram por um SDK da API Qwen, geralmente querem uma biblioteca de clientes que gerencie autenticação, retry, streaming e respostas tipadas. Os SDKs da OpenAI já fazem tudo isso, e este serviço implementa a mesma interface HTTP: POST /v1/chat/completions, POST /v1/responses e GET /v1/models. Qualquer cliente que permita substituir a URL base pode se comunicar com ele.

Um esclarecimento antes de você começar. Esta não é a API oficial da Alibaba ou de qualquer outro fornecedor de modelos, e não é um roteador que encaminha sua solicitação para outro lugar. É um único modelo de pesos abertos, executado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto lícito. O único ID de modelo que você passa é uncensored.

Isso torna a migração simples. Se seu projeto já chama um modelo de chat hospedado através do SDK OpenAI, você altera três valores: a URL base, a chave de API e o nome do modelo. Nada mais no seu código precisa ser alterado.

Instale e faça a primeira chamada

Instale o pacote oficial para Python ou Node. Não há nada específico do serviço para adicionar.

pip install openai
# Node: npm install openai

Crie uma chave na página chave de API, depois exporte-a para que ela nunca caia no seu código-fonte.

export API_KEY="paste-your-key-here"

Agora o script Python mínimo útil. O cliente lê a chave do ambiente e envia solicitações para o serviço em vez de para a OpenAI.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredqwen.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)

Se você preferir HTTP bruto, a mesma solicitação em curl se parece com isto:

curl https://api.uncensoredqwen.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Say hello."}]}'

Streaming de respostas com o SDK

Defina stream=True e itere sobre os blocos. O serviço envia eventos enviados pelo servidor e relata o uso de tokens no final do fluxo, para que você possa registrar o custo sem uma segunda chamada.

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredqwen.com/v1",
                api_key=os.environ["API_KEY"])

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a desk lamp."}],
    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 getattr(chunk, "usage", None):
        print("\nTokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Tenha em mente uma coisa: uma solicitação em streaming mantém seu slot de concorrência até que o fluxo termine. Se um consumidor for lento ou você esquecer de fechar o fluxo, você atingirá o limite de concorrência mais cedo do que imagina.

O mesmo padrão em Node:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredqwen.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Name three uses of JSON mode." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Chamada de ferramentas e modo JSON

Os parâmetros do SDK que você já usa para ferramentas passam direto: tools, tool_choice, streaming tool_calls, e resultados enviados de volta como mensagens com role: "tool". Uma ida e volta mínima se parece com isto:

import os, json
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredqwen.com/v1",
                api_key=os.environ["API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"status": "shipped"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

Para saída estruturada, passe response_format={"type": "json_object"} e também diga "responda em JSON" no prompt. O modo JSON pede ao modelo uma saída JSON, mas seu código ainda deve analisá-la e validar nomes de campos e tipos antes de usá-los.

Configurações de amostragem como temperature, top_p, stop, seed e as penalidades são passadas, então o ajuste existente é mantido.

Trate erros 429 e leia os cabeçalhos

O SDK gera uma exceção de limite de requisições no HTTP 429, e o corpo da resposta informa qual limite você atingiu. Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 requisições simultâneas e 60 por minuto.

Código de erroSignificadoO que fazer
rate_limitedMuitas requisições por minutoEspalhe as chamadas ou adicione um limitador no lado do cliente
concurrencyMuitas requisições de uma vezLimite seu pool de workers em 8 (2 em uma chave de teste)
429 com Retry-After: 5Sobrecarga temporáriaEspere 5 segundos e tente novamente

Cada resposta carrega X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. Para lê-los com o SDK Python, use o wrapper de resposta bruta:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredqwen.com/v1",
                api_key=os.environ["API_KEY"])

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "ping"}],
    max_tokens=5,
)
print("Balance:", raw.headers.get("X-Balance-USD"))
print("Request id:", raw.headers.get("X-Request-Id"))
completion = raw.parse()

Solicitações com falha ou recusadas não são cobradas, portanto, uma nova tentativa após um 429 não custa duas vezes. O artigo existente sobre erros comuns da API Qwen cobre mais dos erros de configuração que as pessoas encontram.

Quanto custa uma chamada

O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, pagos a partir de crédito pré-pago. Faça uma solicitação com 2.000 tokens de prompt e 500 tokens de conclusão:

  • Entrada: 2.000 x $0,15 / 1.000.000 = $0,0003
  • Saída: 500 x $0,50 / 1.000.000 = $0,00025
  • Total: $0.00055

O crédito de teste de $0,50 cobre cerca de 900 solicitações desse tamanho ($0,50 / $0,00055 é aproximadamente 909). O teste é um clique na página de chave após o cadastro, não precisa de cartão e dura 7 dias; o artigo do plano gratuito explica como funciona. Recargas pagas começam em $20, e a página de preços lista os níveis de bônus e métodos de pagamento aceitos.

O contexto é de 100.000 tokens para prompt e conclusão juntos, e max_tokens é opcional. Definir isso ainda é um bom hábito quando você quer um limite superior previsível no custo.

Migrar um projeto existente

A maioria dos leitores chega com código que já chama um modelo de chat. Uma lista de verificação curta mantém a troca sem surpresas:

  1. Altere base_url (ou baseURL em Node) para https://api.uncensoredqwen.com/v1. Mantenha o sufixo /v1 e não adicione /chat/completions você mesmo, porque o SDK anexa o caminho.
  2. Substitua a chave pela que está na sua conta. A autenticação é um cabeçalho Authorization: Bearer padrão, que o SDK constrói para você.
  3. Substitua o nome do modelo por uncensored. Solicitações com um nome de modelo desconhecido falharão, então procure no seu código-fonte por nomes hardcoded.
  4. Remova quaisquer campos de solicitação para recursos que o serviço não oferece, como entradas de imagem ou chamadas de embeddings.
  5. Execute uma chamada para GET /v1/models como um teste de fumaça. Se ele listar o modelo, sua URL e chave estão corretas.

Frameworks que envolvem o cliente OpenAI geralmente expõem as mesmas duas configurações sob nomes como openai_api_base ou OPENAI_BASE_URL. Se sua ferramenta oferecer uma variável de ambiente para a URL base, você pode alterar toda uma aplicação sem tocar em seu código-fonte. Teste com uma chave de teste primeiro, já que seus limites mais baixos de 2 requisições simultâneas e 60 por minuto mostrarão rapidamente se sua aplicação abre mais conexões simultâneas do que você planejou.

O tratamento de contexto merece uma segunda olhada também. A janela aqui é de 100.000 tokens compartilhados entre prompt e conclusão. Se sua configuração antiga cortava o histórico para um tamanho diferente, você pode relaxar ou apertar esse corte para corresponder, mas fique de olho no custo de reenviar um histórico longo a cada turno.

Dicas práticas para código de produção

  • Mantenha a chave fora do repositório. Leia-a de uma variável de ambiente ou de um repositório de segredos, como nos exemplos acima.
  • Defina um tempo limite. O SDK aceita um argumento timeout no cliente. Gerações longas com streaming precisam de um tempo limite de leitura generoso.
  • Limite seus workers. Um pool de threads ou semáforo dimensionado para o seu limite de concorrência evita a maioria dos erros 429 antes que aconteçam.
  • Registre o id da solicitação. Se você entrar em contato com o suporte, o valor de X-Request-Id identifica a chamada.
  • Monitore o saldo. Leia X-Balance-USD das respostas, ou chame GET /v1/balance, para que um trabalho em lote pare antes que o crédito acabe.

O modelo é apenas texto. Não há geração de imagem, áudio ou vídeo, nem embeddings nem fine-tuning, então não planeje em torno desses métodos do SDK. Os detalhes completos dos parâmetros estão na documentação. Os prompts não são usados para treinamento.

Perguntas e respostas

Existe um SDK oficial da API Qwen para este serviço?

Não é necessário um SDK separado. Use o pacote oficial Python ou Node da OpenAI e defina base_url como https://api.uncensoredqwen.com/v1 com o modelo uncensored.

Quais linguagens de SDK funcionam?

Qualquer cliente compatível com OpenAI funciona, incluindo os pacotes oficiais Python e Node, curl puro e bibliotecas da comunidade que permitem substituir a URL base.

Como verifico meu saldo pelo código?

Leia o cabeçalho X-Balance-USD em qualquer resposta ou chame GET /v1/balance. O endpoint estilo OpenAI credit_grants também está disponível.

O SDK suporta streaming e ferramentas?

Sim. Defina stream como true para eventos enviados pelo servidor com uso no final, e use tools e tool_choice como faria com OpenAI.

Sua chave está a um formulário de distância

Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.

Obter chave de API