PT ▾
Obter chave de API

Exemplos da API GLM: Python, modo JSON e streaming

Todos esses exemplos da API GLM usam um único endpoint compatível com OpenAI, com a base URL https://api.glmapikey.com/v1 e o modelo uncensored. Cada snippet é curto e autossuficiente, para que você possa colar, adicionar sua chave e executar.

Atualizado

Janela de terminal com streaming de tokens de dados brilhantes para um servidor na nuvem, ilustrando exemplos de código de API

Pontos principais

  • Cada exemplo usa a base URL https://api.glmapikey.com/v1, autenticação Bearer e o ID do modelo uncensored.
  • Streaming, modo JSON e chamada de funções são todos suportados no mesmo endpoint de chat completions.
  • Leia X-Balance-USD e o bloco de uso para rastrear o gasto por chamada.
  • Trate o 429 por código: rate_limited, concurrency ou um Retry-After: 5 (sobrecarga).

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.

CampoO que fazUso típico
temperatureValores mais altos geram mais variação de texto0,2 para extração, 0,8 para ficção
top_pLimita a amostragem aos tokens mais prováveisDeixe no padrão, a menos que você o ajuste
stopEncerra a resposta quando uma string apareceCorte em um delimitador, como uma linha em branco
seedTorna a amostragem repetível na medida do possívelComparando duas versões de prompt
presence_penalty, frequency_penaltyDesencoraja a repetição de tokensValores 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/completions manualmente 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.loads em 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çalhoO que fazerO que fazer
rate_limitedMuitas requisições por minuto (300 em uma chave completa, 60 em trial)Reduza a frequência e distribua as chamadas
concurrencyMuitas ao mesmo tempo (8 em uma chave completa, 2 em trial)Aguarde uma requisição em execução terminar
Retry-After: 5Sobrecarga temporáriaTente 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.

Perguntas e respostas

Qual base URL os exemplos usam?

Cada exemplo usa https://api.glmapikey.com/v1 com o ID do modelo uncensored e um token Bearer. Qualquer SDK OpenAI funciona assim que você altera esses valores.

A API suporta streaming?

Sim. Defina stream como true e leia server-sent events. O uso é relatado no final do stream.

Como obter JSON válido?

Passe response_format com tipo json_object e descreva a forma desejada no prompt. Analise o resultado no seu código e verifique as chaves que você precisa.

Posso usar chamada de funções?

Sim. Passe tools e tool_choice, execute a função que o modelo solicita e retorne o resultado como uma mensagem com role: tool.

Onde posso ver meu crédito restante?

Cada resposta contém um cabeçalho X-Balance-USD com seu saldo restante, e o bloco de uso fornece as contagens de tokens.

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