Antes de executar qualquer coisa
Você precisa de uma chave e nada mais. Crie uma na página chave de API; novas contas podem reivindicar $0.50 de crédito de teste com um clique, sem cartão. Exporte-a para que os exemplos possam lê-la:
export API_KEY="YOUR_KEY"
pip install openai
npm install openai
A API segue o formato de chat completions da OpenAI. Ela expõe POST /v1/chat/completions e GET /v1/models, aceita Authorization: Bearer e serve um único modelo com o ID uncensored. Esse modelo é um modelo de pesos abertos executado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto legal. Não é a API oficial de nenhum fornecedor de modelo. Ele processa apenas texto: sem imagens, áudio, embeddings ou fine-tuning.
Os exemplos abaixo vão da chamada mais simples à chamada de funções. Se você precisar apenas da verificação mais curta possível de que sua chave funciona, o primeiro comando curl é suficiente.
Uma primeira solicitação com curl e os parâmetros relevantes
curl https://api.glmapikey.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "What is a mutex, in one sentence?"}
],
"temperature": 0.3,
"max_tokens": 80
}'
A resposta é um objeto JSON com choices[0].message.content contendo a resposta e um objeto usage com prompt_tokens e completion_tokens. Os cabeçalhos da resposta incluem X-Request-Id, X-Balance-USD e os dois cabeçalhos X-RateLimit-Limit. Adicione -i ao curl para visualizá-los.
Os campos temperature, top_p, stop, seed e as penalidades de presença e frequência são passados diretamente ao modelo. max_tokens é opcional. Sem ele, a conclusão pode usar tudo o que restar da janela de 100.000 tokens após o seu prompt.
O corpo de chat completions tem muitos campos opcionais, mas cinco fazem a maior parte do trabalho. Todos eles são passados diretamente ao modelo.
| Campo | O que faz | Uso típico |
|---|---|---|
temperature | Valores mais altos geram mais variação de texto | 0,2 para extração, 0,8 para ficção |
top_p | Limita a amostragem aos tokens mais prováveis | Deixe no padrão, a menos que você o ajuste |
stop | Encerra a resposta quando uma string aparece | Corte em um delimitador, como uma linha em branco |
seed | Torna a amostragem repetível na medida do possível | Comparando duas versões de prompt |
presence_penalty, frequency_penalty | Desencoraja a repetição de tokens | Valores pequenos, como 0,3, quando o texto repete |
Altere um valor por vez e mantenha o prompt igual, caso contrário, você não saberá qual alteração ajudou. Para qualquer coisa que processe código, como classificação ou extração, use uma temperatura baixa e uma semente fixa para poder reexecutar um teste e ver o mesmo resultado. Para escrita criativa, aumente a temperatura e deixe as penalidades controlarem a repetição.
O campo max_tokens é opcional aqui. Se você não o definir, a resposta pode usar todo o espaço restante na janela de 100.000 tokens, o que raramente é o desejado para uma resposta de uma linha. Defina-o sempre que souber o tamanho esperado da resposta.
Python: uma conversa com memória
A API é stateless, então você gerencia a conversa e a envia toda vez. Este loop mantém uma lista de mensagens e adiciona ambos os lados:
from openai import OpenAI
client = OpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
messages = [{"role": "system", "content": "You are a helpful assistant."}]
while True:
user = input("you> ")
if not user:
break
messages.append({"role": "user", "content": user})
resp = client.chat.completions.create(model="uncensored", messages=messages)
reply = resp.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
print("bot>", reply)
Como cada chamada reenvia a lista completa, os tokens de entrada crescem com o tamanho do chat. A $0.15 por 1M de tokens de entrada isso é barato, mas se acumula em sessões longas, então corte mensagens antigas assim que o thread ultrapassar o tamanho que você quer pagar. A página de preços tem exemplos práticos.
Streaming em Python e Node
Defina stream: true e o servidor envia tokens conforme são produzidos, via server-sent events. Em Python:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write four lines about the sea."}],
stream=True,
)
text = ""
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text += piece
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
O streaming termina com informações de uso, por isso o loop verifica por elas. A mesma coisa em Node:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.glmapikey.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Write four lines about the sea." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
Um detalhe sobre limites: uma requisição em streaming mantém seu espaço de concorrência até que o stream termine. Se você iniciar um stream e nunca o ler até o fim, esse espaço fica ocupado. Sempre consuma ou feche o stream.
Modo JSON para saída estruturada
Quando seu código precisa analisar a resposta, solicite um objeto JSON com response_format. Também indique no prompt a estrutura desejada, porque o parâmetro de formato garante sintaxe JSON válida, não o seu schema específico.
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
{"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
],
temperature=0.2,
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Verifique se as chaves necessárias existem antes de usá-las e mantenha a temperatura baixa para trabalho de extração. Se a análise falhar, tentar novamente uma vez com a mesma entrada geralmente funciona, e solicitações falhas não são cobradas.
Chamada de funções: uma ida e volta completa
A chamada de funções permite que o modelo peça ao seu código para executar uma função. Você descreve a função em tools, o modelo responde com uma entrada tool_calls, você a executa e envia o resultado de volta como uma mensagem com role: "tool".
import json
def get_weather(city: str) -> dict:
return {"city": city, "temp_c": 18, "sky": "cloudy"}
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(get_weather(**args)),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
else:
print(msg.content)
A função aqui retorna dados fixos, então substitua por uma consulta real. Os argumentos da ferramenta chegam como uma string JSON, então sempre analise-os e valide os valores antes de agir com base neles. Com stream: true, os tool_calls chegam em partes que você deve montar antes de analisar. Use tool_choice para forçar uma ferramenta específica quando precisar disso.
Quanto custam os exemplos e erros que desperdiçam uma hora
Executar os exemplos custa muito pouco, mas ajuda ver a matemática uma vez. A $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída:
- O loop de conversa, com um prompt de 1.200 tokens e uma resposta de 300 tokens: $0.00018 para entrada mais $0.00015 para saída é $0.00033. Mil rodadas custam $0.33.
- A ida e volta da ferramenta faz duas chamadas. Se a primeira usa 400 tokens de entrada e 60 de saída, e a segunda 500 de entrada e 150 de saída, os totais são 900 de entrada e 210 de saída: $0.000135 mais $0.000105 é $0.00024.
- O streaming custa o mesmo que uma chamada normal com as mesmas contagens de tokens. Ele muda quando você vê o texto, não o custo.
O crédito de teste de $0.50 pagaria por mais de 1.500 rodadas do loop de conversa nesse tamanho ($0.50 / $0.00033), então você pode experimentar livremente antes de recarregar. Requisições falhas e recusadas não são cobradas, o que significa que um bug na sua análise que faz você reexecutar uma chamada não cobra as tentativas falhas.
- Uma base URL errada. Ela deve terminar em
/v1. Adicionar/chat/completionsmanualmente a uma base URL do SDK gera 404 porque o SDK adiciona o caminho. - Um nome de modelo diferente. Nomes copiados de outras plataformas não existem aqui. O ID é
uncensored. - Esperando memória. A API não lembra chamadas anteriores. Envie o histórico toda vez.
- Analisando o JSON do modelo sem proteção. Envolva
json.loadsem um bloco try e tenha um plano para uma resposta ruim. - Deixar streams abertos. Um stream inacabado mantém um espaço de concorrência ocupado, e uma chave de teste tem apenas dois.
- Colocando a chave no código front-end. Mantenha-a em um servidor.
Se algo ainda parecer errado, envie uma requisição com curl e compare com o que seu código produz. A forma curl remove o SDK da equação e torna evidentes as diferenças no corpo.
Lendo uso, saldo e erros
Para ver os cabeçalhos do SDK Python, use o wrapper de resposta bruta:
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)
Registre o ID da requisição em cada chamada para poder apontar para uma única requisição depois. Use o cabeçalho de saldo para disparar um alerta antes que o crédito acabe.
Quando você ultrapassa um limite, a API retorna HTTP 429, e o código de erro indica qual:
| Código ou cabeçalho | O que fazer | O que fazer |
|---|---|---|
rate_limited | Muitas requisições por minuto (300 em uma chave completa, 60 em trial) | Reduza a frequência e distribua as chamadas |
concurrency | Muitas ao mesmo tempo (8 em uma chave completa, 2 em trial) | Aguarde uma requisição em execução terminar |
Retry-After: 5 | Sobrecarga temporária | Tente novamente após cinco segundos |
Requisições falhas ou recusadas não são cobradas. O corpo da requisição pode ter até 8 MB. Para a referência completa e como reutilizar código de cliente existente, consulte a documentação. Para um passo a passo de como obter uma chave, consulte o artigo da chave API GLM.
