BroadRouter

Um endpoint privado começa com uma carga de trabalho clara

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em

Antes de pedir um endpoint privado, registre a carga de trabalho: requisições por dia e no pico, tokens de entrada e saída, a concorrência que isso implica, o contexto necessário, a região de processamento, o modelo e sua licença, e um orçamento. Combine região e limites por escrito e faça um smoke test no endpoint recebido antes de usar dados reais.

“Precisamos de um endpoint dedicado” é o começo de uma conversa, não uma especificação. O provedor não consegue dimensionar, posicionar nem precificar capacidade sem os seus números, e sem eles você também não consegue avaliar a resposta. Este post lista o que definir antes de pedir, com um exemplo de extração de dados de notas fiscais, e termina com um script que confere o endpoint que você receber.

Vale para qualquer provedor. Onde descreve a oferta da BroadNet, ele se limita ao que a BroadNet diz publicamente, conferido em 15 de novembro de 2026. Qualquer coisa além disso é pergunta para a BroadNet.

Quando um endpoint privado faz sentido?

Geralmente por um destes quatro motivos:

  • Tráfego acima dos limites do autoatendimento. A referência da API da BroadNet publica 30 requisições por minuto e 4 requisições simultâneas para uma chave de pagamento por uso. Uma carga constante acima disso é questão de capacidade, não de novas tentativas. (Como lidar com 429 cobre picos curtos.)
  • Um modelo que não está na lista pública. O catálogo da BroadNet marca alguns modelos como “available on request” (disponíveis sob consulta), entre eles Qwen3-VL 30B-A3B, Qwen3-VL 8B e um fine-tune da BroadNet do Cohere Transcribe Arabic. Como ler um catálogo de modelos explica a diferença.
  • Um local de processamento que você precisa controlar. Regras de residência de dados, como as do checklist da PDPL da Arábia Saudita e dos Emirados, podem exigir uma região combinada por escrito.
  • Latência previsível. A capacidade compartilhada varia com a carga dos outros usuários. A capacidade reservada elimina essa variável, mas não a distância de rede nem o tamanho dos seus prompts.

Se nenhum desses motivos se aplica, uma chave de autoatendimento é mais simples. E, se o seu volume é muito alto e constante, compare com rodar por conta própria: self-hosting vs. custo de API traz o método.

O que definir sobre a carga de trabalho?

Escreva um briefing de uma página. Estes são os números de que um provedor precisa:

Item O que anotar Exemplo
Tarefa O que o modelo faz, em uma frase Lê fotos de notas fiscais e devolve campos em JSON
Volume Requisições por dia e a fatia na hora de pico 40.000 por dia, 15% na hora de pico
Tokens Média e percentil 95 de tokens de entrada e saída 1.800 de entrada (imagem de uma página + prompt), 350 de saída
Contexto A maior requisição individual, prompt mais resposta 4.000 tokens
Latência Tempo aceitável até o primeiro token e até a resposta completa Resposta completa em até 10 segundos
Streaming Necessário ou não Não necessário (estilo lote)
Entradas Texto, imagens, áudio; formatos e tamanhos JPEG e PNG, uma página cada
Idiomas Quais, e a fatia de cada um Árabe e inglês, 60/40
Crescimento Volume esperado em 6 e 12 meses O dobro em 12 meses

Meça as contagens de tokens em amostras reais, não em chutes. O árabe costuma precisar de mais tokens que o inglês para o mesmo texto; o contador de tokens em árabe e o custo real por idioma mostram quanto em tokenizers diferentes. Para imagens, a calculadora de tokens de imagem dá uma primeira estimativa.

Como transformar volume em tokens por segundo e concorrência?

As requisições por segundo no pico são o volume da hora de pico dividido por 3.600. A concorrência, o número de requisições em andamento ao mesmo tempo, sai da lei de Little: o número médio de itens em um sistema é igual à taxa de chegada vezes o tempo médio que cada um passa nele. Para uma API, isso é requisições por segundo × segundos por requisição.

import math

def size(requests_per_day: int, peak_share_of_day_in_busiest_hour: float,
         in_tokens: int, out_tokens: int, out_tok_per_s_per_stream: float) -> dict:
    """Rough peak numbers to put in a capacity enquiry. Measure your own inputs; these are not provider specs."""
    peak_rps = requests_per_day * peak_share_of_day_in_busiest_hour / 3600
    seconds_per_request = out_tokens / out_tok_per_s_per_stream        # ignores queueing and prompt time
    concurrency = peak_rps * seconds_per_request                      # Little's law: L = λ × W
    return {
        "peak_requests_per_second": round(peak_rps, 2),
        "seconds_per_request": round(seconds_per_request, 1),
        "concurrent_requests_at_peak": math.ceil(concurrency),
        "peak_input_tokens_per_second": round(peak_rps * in_tokens),
        "peak_output_tokens_per_second": round(peak_rps * out_tokens),
        "monthly_tokens_millions": round(requests_per_day * 30 * (in_tokens + out_tokens) / 1e6, 1),
    }

# 40,000 invoice extractions a day, 15% of them in the busiest hour,
# 1,800 tokens in, 350 out, 60 tokens/s per stream measured on a trial.
print(size(40_000, 0.15, 1_800, 350, 60))

Ele imprimiu 1,67 requisição por segundo no pico, cerca de 5,8 segundos por requisição, 10 requisições simultâneas, 3.000 tokens de entrada e 583 de saída por segundo, e 2.580 milhões de tokens por mês. Os 60 tokens por segundo são uma suposição do exemplo; meça os seus no modelo que você vai usar, porque a velocidade varia com o modelo, o tamanho do prompt e a carga. O post sobre latência, TTFT e throughput explica o que cronometrar.

Dois cuidados. A fórmula ignora o tempo de processamento do prompt, então prompts longos ou imagens grandes deixam as requisições reais mais lentas e aumentam a concorrência. E médias escondem picos: passe ao provedor o tamanho de requisição no percentil 95 e um perfil curto de rajadas, não só a média. O pico deste exemplo (cerca de 100 requisições por minuto e 10 em andamento) fica bem acima dos limites publicados de autoatendimento para uma chave de pagamento por uso, e é exatamente aí que vale a pena conversar sobre capacidade.

E região, residência e limites?

Combine tudo explicitamente, por escrito, antes que qualquer dado regulado circule. Os Termos da BroadNet (§7.3a) dizem: “Contact us to agree processing locations for your deployment before sending data with residency requirements” (tradução: fale conosco para combinar os locais de processamento da sua implantação antes de enviar dados com requisitos de residência), e que o processamento hospedado por parceiros e o de backup envolvem outros operadores, com uma lista atualizada de suboperadores disponível aos clientes mediante solicitação. A declaração de privacidade diz que os modelos próprios e os modelos open-weight hospedados pela BroadNet rodam em hardware próprio ou alugado pela BroadNet nos Estados Unidos, com capacidade de parceiros como backup, e a página de visão geral diz que processamento regional no MENA ou na Europa está disponível sob consulta.

Então as perguntas para qualquer provedor são:

  1. Qual região processa as requisições e qual região guarda a capacidade de backup?
  2. Quais suboperadores podem tocar no tráfego, inclusive em failover ou excesso de demanda?
  3. Quais são os limites de taxa, concorrência e tokens do endpoint, e o que acontece acima deles?
  4. Que termos de disponibilidade e suporte se aplicam, e onde estão escritos? Os Termos da BroadNet (§7.4) dizem que o autoatendimento não tem compromisso de disponibilidade e que endpoints privados e capacidade reservada seguem o seu acordo escrito separado. Para ver o que os SLAs escritos de outros provedores cobrem, leia SLAs de APIs de LLM comparados.
  5. O que é retido? Para a API de inferência da BroadNet, a posição publicada é: o conteúdo das requisições de inferência não é retido; os metadados necessários de conta, cobrança e segurança são retidos conforme descrito na declaração de privacidade. Confirme que o mesmo vale para o seu endpoint.

Qual modelo, e com qual licença?

Indique o modelo e a versão exatos e confira se a licença permite o seu uso e o serving via API. As páginas de modelos da BroadNet listam Apache-2.0 para Gemma 4 26B, Qwen3-VL 30B-A3B e os pesos base do Cohere Transcribe, com o fine-tune da BroadNet do Cohere Transcribe Arabic “under contract” (sob contrato). Os Termos dizem que os modelos são regidos por suas licenças e que a licença do DeepSeek V4.1 Flash continua valendo quando ele é hospedado por parceiros.

Combine também a janela de contexto. Os limites de contexto dependem do modelo e da implantação, não só do máximo do modelo base: a BroadNet lista 32K tokens para o Gemma 4 VL 26B na API pública e 16K para o Qwen3-VL 30B-A3B, que é sob consulta. Use a calculadora de janela de contexto com a sua maior requisição, não com a média.

Como definir um orçamento?

A BroadNet não publica preço de endpoint privado; a página de visão geral diz “Reserved GPU, priced to your traffic. Ask for a quote.” (tradução: GPU reservada, com preço conforme o seu tráfego. Peça um orçamento.). Então defina antes o seu próprio teto. Precifique a mesma carga no autoatendimento com a calculadora de custo de API de LLM, usando a contagem mensal de tokens do script de dimensionamento, e decida quanto valem para você, além disso, capacidade previsível, uma região ou um modelo que não é público. Um orçamento abaixo do valor de autoatendimento é bônus; um muito acima precisa de uma justificativa na sua lista de requisitos.

Como enviar a consulta?

A referência da API da BroadNet diz: “Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint” (tradução: endpoints privados, nossos fine-tunes para árabe e outros modelos sob consulta são acessados com um ID privado emitido junto com o endpoint). A página de visão geral pede “your model, languages and traffic requirements” (tradução: seu modelo, idiomas e requisitos de tráfego). Envie seu briefing de uma página pela página de contato, sem chaves de API nem dados de clientes. Inclua a saída do dimensionamento, a região, o modelo e a licença, a meta de latência, o teto de orçamento e o seu cronograma.

Como validar o endpoint recebido?

Antes do tráfego de produção, teste o endpoint contra o que foi combinado. Este script usa só a biblioteca padrão do Python. Ele confere se o ID privado do modelo funciona, se o streaming termina com o marcador data: [DONE] que a documentação da BroadNet descreve, se a concorrência combinada roda sem 429 e se um ID de modelo errado é rejeitado.

import json, os, sys, time, urllib.error, urllib.request
from concurrent.futures import ThreadPoolExecutor

BASE = os.environ["ENDPOINT_BASE_URL"].rstrip("/")    # from your agreement, e.g. https://.../v1
KEY = os.environ["ENDPOINT_API_KEY"]
MODEL = os.environ["ENDPOINT_MODEL_ID"]                # the private ID issued with the endpoint
AGREED_CONCURRENCY = int(os.environ.get("AGREED_CONCURRENCY", "4"))

def post(payload: dict, stream=False):
    req = urllib.request.Request(f"{BASE}/chat/completions", data=json.dumps(payload).encode(),
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"})
    t0 = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=120) as r:
            body = r.read().decode()
            return r.status, r.headers.get("X-Request-ID"), body, time.monotonic() - t0
    except urllib.error.HTTPError as e:
        return e.code, e.headers.get("X-Request-ID"), e.read().decode(), time.monotonic() - t0

def main() -> int:
    msg = [{"role": "user", "content": "Reply with the word OK."}]
    results = {}
    code, rid, body, secs = post({"model": MODEL, "messages": msg, "max_tokens": 1000})
    ok = code == 200 and "usage" in json.loads(body)
    results["model_id_accepted"] = (ok, f"HTTP {code}, request ID {rid}, {secs:.2f}s")
    code, _, body, _ = post({"model": MODEL, "messages": msg, "stream": True,
                             "stream_options": {"include_usage": True}})
    results["stream_ends_with_DONE"] = (code == 200 and body.rstrip().endswith("data: [DONE]"), f"HTTP {code}")
    with ThreadPoolExecutor(AGREED_CONCURRENCY) as pool:
        codes = list(pool.map(lambda _: post({"model": MODEL, "messages": msg, "max_tokens": 1000})[0],
                              range(AGREED_CONCURRENCY)))
    results["agreed_concurrency_no_429"] = (all(c == 200 for c in codes), f"codes {sorted(codes)}")
    code, _, _, _ = post({"model": MODEL + "-typo", "messages": msg})
    results["unknown_model_rejected"] = (code in (400, 403, 404), f"HTTP {code}")
    for name, (passed, note) in results.items():
        print(f"{'PASS' if passed else 'FAIL'}  {name}: {note}")
    return 0 if all(p for p, _ in results.values()) else 1

if __name__ == "__main__":
    sys.exit(main())

Rodamos o script contra um servidor mock local (sem endpoint real) que permite 8 requisições simultâneas. Com AGREED_CONCURRENCY=8, as quatro verificações passaram. Com 12, a verificação de concorrência falhou com oito 200 e quatro 429, que é o resultado que você quer ver antes do lançamento, não depois. max_tokens=1000 deixa espaço para modelos de raciocínio, que gastam parte do orçamento antes de responder.

Depois do smoke test, rode um teste de carga curto no seu pico medido, com prompts de tamanho real, e registre o tempo até o primeiro token e a latência da resposta completa do endpoint. Guarde os request IDs; a documentação da BroadNet pede o X-Request-ID, o timestamp, a rota e o status nos pedidos de suporte.

Onde a BroadNet Inference se encaixa

O BroadRouter é o site da própria BroadNet. A BroadNet Inference vende acesso de autoatendimento a modelos públicos por token, por minuto de áudio, por plano de sessão e por chave por hora; os preços estão na página de preços. Endpoints privados, processamento regional, fine-tunes e modelos listados “on request” (sob consulta) não são autoatendimento: são consultas que a BroadNet orça e combina por escrito. Este post não pode dizer o que a BroadNet vai oferecer para a sua carga de trabalho. Um briefing claro é como você descobre.

Perguntas frequentes

O que é um endpoint privado de LLM?

Um endpoint de API apoiado em capacidade reservada para um único cliente, em vez de compartilhada com todos os usuários de autoatendimento. A BroadNet descreve a versão dela como uma GPU ou nó reservado com o modelo que você escolher, chave e limites próprios e a região de que você precisa, acessado por um ID de modelo privado.

Como estimar a concorrência de que preciso?

Use a lei de Little: requisições simultâneas = requisições por segundo no pico × segundos por requisição. 1,67 requisição por segundo com cerca de 5,8 segundos cada dá cerca de 10 requisições em andamento. Meça os segundos por requisição no modelo real, com os seus prompts reais.

Posso contratar um endpoint privado da BroadNet por autoatendimento?

Não. A BroadNet trata endpoints privados, processamento regional e modelos fora da lista como consultas: você descreve a carga de trabalho e a BroadNet faz um orçamento. Os Termos dela dizem que endpoints privados e capacidade reservada seguem um acordo escrito separado.

Um endpoint privado vem com SLA?

Só se o seu acordo escrito disser isso. Os Termos da BroadNet afirmam que o autoatendimento não tem compromisso de disponibilidade e que níveis de serviço só existem em um acordo escrito separado. Peça os termos exatos antes de contar com eles.

Onde meus dados serão processados?

Combine isso antes de enviar dados. Os Termos da BroadNet pedem que clientes com requisitos de residência combinem antes os locais de processamento, e dizem que o processamento hospedado por parceiros e o de backup envolvem outros operadores, com uma lista de suboperadores disponível aos clientes mediante solicitação.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity