WaveSpeedAI

GLM-4.7-Flash API: Chat Completions & Streaming Quick Start

GLM-4.7-Flash API: Chat Completions & Streaming Quick Start

Oi, meu nome é Dora. Semana passada enfrentei um pequeno problema: uma tarefa de resumo de rascunho que se sentia mais pesada do que deveria. As ferramentas que normalmente uso eram ou muito lentas ou muito sofisticadas demais para o próprio bem. Eu queria algo rápido e previsível, mesmo que não fosse impressionante.

Então dei a GLM-4.7-Flash API um teste adequado (janeiro de 2026). Eu não estava procurando por um “uau”. Queria requisições limpas, respostas rápidas e configurações que funcionassem da forma que dizem funcionar. Aqui está o que configurei, o que ajudou, onde tropeçou e por que a usaria novamente quando preciso de velocidade sem drama.

Obtenha sua Chave de API

Comecei simples: obter uma chave, fazer uma requisição, ver se o básico faz sentido. Gosto de APIs que não escondem os comandos. Para contexto, GLM-4.7-Flash faz parte da família de modelos GLM mais ampla da Zhipu AI, que norteia muitas das decisões de design em torno de velocidade e previsibilidade.

Passo a Passo do Painel WaveSpeed

Usei o painel WaveSpeed, que envolve o acesso à API GLM-4.7-Flash. O fluxo era simples o suficiente:

  • Criar um projeto (nomeei o meu de “flash-notes”).
  • Gerar uma chave de servidor e um token de cliente leve. Usei apenas a chave de servidor em meus scripts locais.
  • Verificar o painel de uso para notar os limites de taxa padrão. O meu mostrava um limite de pico modesto e uma cota por minuto, suficiente para testes mas não para um pico de produção.

Uma coisa pequena que gostei: o painel mostra erros 4xx/5xx recentes com carimbos de data/hora. Quando atingi limites mais tarde, não tive que adivinhar. Se você está fazendo trabalho em equipe, a visibilidade de chave baseada em papéis ajudou: mantive a chave com capacidade de escrita em um arquivo .env e rotacionei uma vez durante a semana para verificar que a revogação funcionou (funcionou, instantaneamente).

Requisição Básica

Meu primeiro ponto de verificação foi o mesmo que uso para qualquer novo modelo: um prompt curto, uma resposta curta e sem surpresas no JSON.

O esquema da API segue o mesmo padrão de conclusão de chat descrito no guia oficial da API GLM-4.7, o que significava que não precisava reaprender a semântica de requisição.

Exemplo curl

Aqui está a chamada mais simples que funcionou consistentemente para mim. O nome do endpoint pode variar entre provedores: este é o padrão que usei durante os testes.

curl https://api.wavespeed.ai/v1/chat/completions \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "GLM-4.7-Flash",
    "messages": [
      {"role": "system", "content": "You are concise and helpful."},
      {"role": "user", "content": "Summarize this in one sentence: GLM-4.7-Flash API quick test."}
    ],
    "temperature": 0.2,
    "max_tokens": 120
  }'

Notas da execução

  • Latência: Vi o primeiro token em ~200–400 ms em um prompt pequeno no meio da manhã (horário dos EUA). Conclusão de ponta a ponta em menos de um segundo para respostas curtas.
  • Estabilidade: As respostas foram JSON bem-formado todas as vezes quando o streaming estava desativado.
  • Custo: Não posso falar sobre seu plano, mas os tokens foram relatados claramente nos registros de uso. Isso importa quando você está impulsionando iterações rápidas.

Exemplo em Python

Para scripts pequenos, prefiro uma única função com chaves carregadas do ambiente.

import os
import requests

API_KEY = os.getenv("WAVESPEED_API_KEY")
BASE_URL = "https://api.wavespeed.ai/v1/chat/completions"

payload = {
    "model": "GLM-4.7-Flash",
    "messages": [
        {"role": "system", "content": "You are concise and helpful."},
        {
            "role": "user",
            "content": "Give me 3 bullet points on maintaining a calm writing workflow."
        }
    ],
    "temperature": 0.3,
    "max_tokens": 180
}

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

resp = requests.post(BASE_URL, json=payload, headers=headers, timeout=30)
resp.raise_for_status()

data = resp.json()
print(data["choices"][0]["message"]["content"])  # typical OpenAI-style schema

Duas pequenas reações:

  • Alívio: O esquema correspondeu ao formato usual de conclusão de chat, o que significava nenhuma camada adaptadora. Coloquei em uma ferramenta pré-existente com mudanças mínimas.
  • Uma limitação: Saídas mais longas em temperatura mais alta às vezes divagavam. Isso é normal para modelos do tipo “Flash”: cortei com max_tokens e ajustei o tom através de um prompt de sistema mais apertado.

Ativar Streaming

Só ativo o streaming quando estou moldando texto ao vivo ou quando a latência importa mais que a completude. GLM-4.7-Flash parecia feito para isso: primeiros tokens rápidos, chunking estável uma vez que os parâmetros foram definidos corretamente.

Configuração do Parâmetro Stream

Para ativar eventos enviados pelo servidor (SSE), defino stream: true. Só isso. O resto é limpeza: certifique-se de que seu cliente leia linhas de evento e pare em [DONE].

Versão curl que usei:

curl https://api.wavespeed.ai/v1/chat/completions \
-H "Authorization: Bearer $WAVESPEED_API_KEY" \
-H "Content-Type: application/json" \
-N \
-d '{
  "model": "GLM-4.7-Flash",
  "messages": [
    {"role": "user", "content": "Draft a two-sentence intro about quiet tools."}
  ],
  "stream": true,
  "temperature": 0.2,
  "max_tokens": 120
}'

Dois apontamentos de campo:

  • Se você esquecer -N (no-buffer) com curl, o stream pode parecer travado.
  • Se você receber um blob JSON simples em vez de eventos, verifique novamente que stream é booleano true e não uma string.

Lidar com Chunks no Código

Em Python, leio linha por linha, analiso frames data: e paro no sentinela. Este padrão funcionou perfeitamente.

import os, json, requests

API_KEY = os.getenv("WAVESPEED_API_KEY")
BASE_URL = "https://api.wavespeed.ai/v1/chat/completions"

payload = {
    "model": "GLM-4.7-Flash",
    "messages": [{"role": "user", "content": "Write a calm closing paragraph."}],
    "stream": True,
    "temperature": 0.2,
}

with requests.post(
    BASE_URL,
    json=payload,
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    stream=True,
    timeout=60
) as r:
    r.raise_for_status()
    for line in r.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        data = line[len("data:"):].strip()
        if data == "[DONE]":
            break
        try:
            delta = json.loads(data)["choices"][0]["delta"].get("content", "")
            print(delta, end="", flush=True)
        except (KeyError, json.JSONDecodeError):
            # Skip malformed or heartbeat frames gracefully
            continue

print()  # newline

O que me surpreendeu um pouco: o timing dos chunks era constante. Tentei alguns prompts mais longos e ainda recebi um ritmo previsível. O streaming não economizou tempo de relógio em respostas muito curtas, mas reduziu meu senso de espera, o que importa quando estou editando diretamente no terminal.

Referência de Parâmetros

Ajusto apenas alguns botões dia a dia. Com a API GLM-4.7-Flash, eles se comportaram como esperado.

temperature / top_p / max_tokens

  • temperature: Mantive isso entre 0,1 e 0,4 para tarefas saborizadas em produção. Números mais baixos davam fraseado mais apertado e menos imaginativo, que é bom para resumos e texto de suporte. Se você derivar acima de 0,7, espere tangentes.
  • top_p: Deixei top_p em torno de 0,9. Quando apertei para 0,6 com temperatura baixa, as saídas pareciam cortadas, útil para pontos com bullets, menos para escrita matizada.
  • max_tokens: Este era meu guarda-chuva. Para tarefas de forma curta, 150–250 mantinha os custos organizados e impedia divagações. Para esboços, 600–800 era o suficiente. Se o modelo parar cedo, é geralmente isso, não um bug.

Uma pequena configuração que funcionou bem para mim quando precisava de respostas crispas e factuais:

{
  "model": "GLM-4.7-Flash",
  "temperature": 0.2,
  "top_p": 0.9,
  "max_tokens": 200
}

Por que isso importa na prática: quando você quer velocidade, você não quer reescritas. Uma temperatura conservadora com um max_tokens generoso mas não ilimitado me salvou de ter que executar a mesma chamada duas vezes apenas para aparar a fraseado.

Erros Comuns

Mantive um pequeno bloco de notas ao meu lado durante o teste. Dois erros surgiram o suficiente para valer a pena mencionar claramente.

Limite de Taxa 429

O que vi:

  • Explosões de requisições paralelas (5–10 de uma vez) às vezes disparavam um 429. Acontecia mais no primeiro minuto de uma chave nova.

O que ajudou:

  • Backoff: atraso exponencial com jitter (por exemplo, 200 ms, 400 ms, 800 ms, até ~3 s) limpou picos sem eu ficar observando.
  • Filas: coalescing de prompts quase idênticos em uma janela curta (100–200 ms) reduziu minha taxa de pico em ~30% sem alterar UX.
  • Verificações de painel: o painel de uso confirmou quando eu era o problema. Sem mistério lá, o que apreciei.

Quem isso dispara: equipes conectando GLM-4.7-Flash em pré-visualizações de UI e ganchos de servidor ao mesmo tempo. Se importar, pergunte ao seu provedor sobre limites mais altos por minuto ou use uma fila leve em memória.

Resposta JSON Inválida

O que vi:

  • Quando o streaming está ativado, alguns clientes tentam analisar cada frame data: como JSON completo. Não é assim que SSE funciona. Os frames são parciais.
  • Uma vez, com uma conexão barulhenta, obtive uma linha de evento truncada que quebrou analisadores rigorosos.

O que ajudou:

  • Proteja seu parser: apenas analise o JSON após data: e espere que ele contenha um pequeno delta, não a mensagem completa. Pare em [DONE].
  • Timeouts: mantenha um timeout de leitura razoável mas evite matar um stream por um único frame malformado.
  • Se você precisar de JSON não-stream: desative o stream e você geralmente obterá um objeto JSON único e limpo. Nas minhas execuções, o modo não-stream nunca produziu JSON malformado.

Um snag menor: se seu proxy ou servidor injetar logs em stdout, pode poluir o stream. Mantenha logs separados dos pipes de resposta.

Depois de todo este teste, o motivo pelo qual fiquei com WaveSpeed é bem simples: eu não queria pensar na encanação. Construímos WaveSpeed para ser a camada chata e confiável entre seu código e modelos rápidos como GLM-4.7-Flash. Endpoints limpos, comportamento previsível e um painel que te diz o que realmente aconteceu quando algo dá errado—limites de taxa, erros, uso—sem adivinhação.

Se você está conectando Flash em resumos, rascunhos, pré-visualizações de UI ou trabalhos em background e apenas quer que fique fora do caminho, essa é exatamente a lacuna que estamos tentando preencher. → Clique aqui!