BroadRouter

Un endpoint privato parte da un carico di lavoro chiaro

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato

Prima di chiedere un endpoint privato, metti per iscritto il carico di lavoro: richieste al giorno e nel picco, token in ingresso e in uscita, la concorrenza che ne deriva, il contesto necessario, la regione di elaborazione, il modello e la sua licenza, e un budget. Concorda per iscritto regione e limiti, poi fai uno smoke test sull’endpoint ricevuto prima di usare dati reali.

“Ci serve un endpoint dedicato” è l’inizio di una conversazione, non una specifica. Il provider non può dimensionare, collocare o prezzare la capacità senza i tuoi numeri, e senza di essi nemmeno tu puoi giudicare la sua risposta. Questo articolo elenca che cosa definire prima di chiedere, con un esempio concreto di estrazione dati dalle fatture, e si chiude con uno script che verifica l’endpoint che ricevi.

Vale per qualsiasi provider. Dove descrive l’offerta di BroadNet, si limita a ciò che BroadNet dice pubblicamente, verificato il 15 novembre 2026. Tutto il resto è una domanda da fare a BroadNet.

Quando ha senso un endpoint privato?

Di solito per uno di quattro motivi:

  • Traffico oltre i limiti self-service. Il riferimento API di BroadNet pubblica 30 richieste al minuto e 4 richieste in corso per una chiave a consumo. Un carico costante oltre queste soglie è una questione di capacità, non di retry. (Gestire gli errori 429 copre i picchi brevi.)
  • Un modello che non è nell’elenco pubblico. Il catalogo di BroadNet segna alcuni modelli come “available on request” (disponibili su richiesta), tra cui Qwen3-VL 30B-A3B, Qwen3-VL 8B e un fine-tune di BroadNet di Cohere Transcribe Arabic. Leggere un catalogo di modelli spiega la differenza.
  • Un luogo di elaborazione che devi controllare. Le norme sulla residenza dei dati, come quelle della checklist PDPL per Arabia Saudita ed Emirati, possono richiedere una regione concordata per iscritto.
  • Latenza prevedibile. La capacità condivisa varia con il carico degli altri utenti. La capacità riservata elimina questa variabile, anche se non la distanza di rete né la dimensione dei tuoi prompt.

Se nessuno di questi motivi vale per te, una chiave self-service è più semplice. E se il tuo volume è molto alto e costante, fai un confronto con la gestione in proprio: self-hosting o API, i costi contiene il metodo.

Che cosa definire del carico di lavoro?

Scrivi un brief di una pagina. Questi sono i numeri che servono a un provider:

Voce Che cosa scrivere Esempio
Compito Che cosa fa il modello, in una frase Legge foto di fatture, restituisce campi JSON
Volume Richieste al giorno e quota nell’ora di punta 40.000 al giorno, il 15% nell’ora di punta
Token Token medi e al 95° percentile in ingresso e in uscita 1.800 in ingresso (immagine di una pagina + prompt), 350 in uscita
Contesto La singola richiesta più grande, prompt più risposta 4.000 token
Latenza Tempo accettabile al primo token e alla risposta completa Risposta completa entro 10 secondi
Streaming Necessario o no Non necessario (in stile batch)
Input Testo, immagini, audio; formati e dimensioni JPEG e PNG, una pagina ciascuno
Lingue Quali, e la quota di ciascuna Arabo e inglese, 60/40
Crescita Volume previsto a 6 e 12 mesi Il doppio in 12 mesi

Misura i conteggi dei token su campioni reali, non a stima. L’arabo richiede spesso più token dell’inglese per lo stesso testo; il contatore di token per l’arabo e il costo reale per lingua mostrano di quanto con tokenizer diversi. Per le immagini, il calcolatore di token per immagini dà una prima stima.

Come si trasforma il volume in token al secondo e concorrenza?

Le richieste al secondo nel picco sono il volume dell’ora di punta diviso per 3.600. La concorrenza, cioè il numero di richieste in corso nello stesso momento, segue dalla legge di Little: il numero medio di elementi in un sistema è uguale alla frequenza di arrivo per il tempo medio che ciascuno vi trascorre. Per un’API: richieste al secondo × secondi per richiesta.

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))

Ha stampato 1,67 richieste al secondo nel picco, circa 5,8 secondi per richiesta, 10 richieste concorrenti, 3.000 token di input e 583 di output al secondo, e 2.580 milioni di token al mese. I 60 token al secondo sono un’ipotesi per l’esempio; misura i tuoi sul modello che userai, perché la velocità varia con il modello, la lunghezza del prompt e il carico. L’articolo su latenza, TTFT e throughput spiega che cosa cronometrare.

Due avvertenze. La formula ignora il tempo di elaborazione del prompt, quindi prompt lunghi o immagini grandi rendono le richieste reali più lente e fanno salire la concorrenza. E le medie nascondono i picchi: dai al provider la dimensione delle richieste al 95° percentile e un breve profilo dei burst, non solo la media. Il picco di questo esempio (circa 100 richieste al minuto e 10 in corso) è ben oltre i limiti self-service pubblicati per una singola chiave a consumo, ed è proprio il momento in cui vale la pena parlare di capacità.

E regione, residenza e limiti?

Concordali esplicitamente, per iscritto, prima di spostare qualsiasi dato regolamentato. I Termini di BroadNet (§7.3a) dicono: «Contact us to agree processing locations for your deployment before sending data with residency requirements» (traduzione: contattaci per concordare i luoghi di elaborazione del tuo deployment prima di inviare dati con requisiti di residenza), e che l’elaborazione ospitata da partner e quella di backup coinvolgono altri responsabili del trattamento, con un elenco aggiornato dei sub-responsabili disponibile ai clienti su richiesta. La sua informativa privacy dice che i modelli open-weight propri e ospitati da BroadNet girano su hardware di proprietà o in leasing di BroadNet negli Stati Uniti, con capacità di partner come backup, e la pagina di panoramica dice che l’elaborazione regionale in MENA o in Europa è disponibile su richiesta.

Le domande da fare a qualsiasi provider sono quindi:

  1. Quale regione elabora le richieste, e quale regione ospita la capacità di backup?
  2. Quali sub-responsabili possono toccare il traffico, anche in caso di failover o di sovraccarico?
  3. Quali sono i limiti di frequenza, concorrenza e token dell’endpoint, e che cosa succede oltre?
  4. Quali termini di disponibilità e di supporto si applicano, e dove sono scritti? I Termini di BroadNet (§7.4) dicono che il self-service non ha impegni di disponibilità e che endpoint privati e capacità riservata seguono il tuo accordo scritto separato. Per vedere che cosa coprono gli SLA scritti di altri provider, leggi gli SLA delle API LLM a confronto.
  5. Che cosa viene conservato? Per l’API di inferenza di BroadNet, la posizione pubblicata è: il contenuto delle richieste di inferenza non viene conservato; i metadati necessari di account, fatturazione e sicurezza vengono conservati come descritto nella sua informativa privacy. Verifica che valga lo stesso per il tuo endpoint.

Quale modello, e con quale licenza?

Indica il modello e la versione esatti, e controlla che la licenza consenta il tuo uso e il serving via API. Le pagine dei modelli di BroadNet indicano Apache-2.0 per Gemma 4 26B, Qwen3-VL 30B-A3B e i pesi di base di Cohere Transcribe, mentre il fine-tune di BroadNet di Cohere Transcribe Arabic è «under contract» (sotto contratto). I suoi Termini dicono che i modelli sono regolati dalle rispettive licenze, e che la licenza di DeepSeek V4.1 Flash si applica anche quando è ospitato da partner.

Concorda anche la finestra di contesto. I limiti di contesto dipendono dal modello e dal deployment, non solo dal massimo del modello di base: BroadNet indica 32K token per Gemma 4 VL 26B sulla sua API pubblica e 16K per Qwen3-VL 30B-A3B, che è su richiesta. Usa il calcolatore della finestra di contesto sulla tua richiesta più grande, non su quella media.

Come si fissa un budget?

BroadNet non pubblica un prezzo per gli endpoint privati; la sua pagina di panoramica dice «Reserved GPU, priced to your traffic. Ask for a quote.» (traduzione: GPU riservata, con prezzo in base al tuo traffico. Chiedi un preventivo.). Fissa quindi prima un tuo tetto. Prezza lo stesso carico in self-service con il calcolatore dei costi delle API LLM, usando il conteggio mensile dei token dello script di dimensionamento, e decidi quanto valgono per te, in aggiunta, capacità prevedibile, una regione o un modello non pubblico. Un preventivo sotto la cifra self-service è un bonus; uno molto sopra richiede una giustificazione dal tuo elenco di requisiti.

Come si invia la richiesta?

Il riferimento API di BroadNet dice: «Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint» (traduzione: gli endpoint privati, i nostri fine-tune per l’arabo e gli altri modelli su richiesta si raggiungono con un ID privato rilasciato insieme all’endpoint). La sua pagina di panoramica chiede «your model, languages and traffic requirements» (traduzione: il tuo modello, le lingue e i requisiti di traffico). Invia il tuo brief di una pagina dalla pagina dei contatti, senza chiavi API né dati dei clienti. Includi l’output del dimensionamento, la regione, il modello e la licenza, l’obiettivo di latenza, il tetto di budget e le tue tempistiche.

Come si convalida l’endpoint ricevuto?

Prima del traffico di produzione, testa l’endpoint rispetto a quanto concordato. Questo script usa solo la libreria standard di Python. Verifica che l’ID privato del modello funzioni, che lo streaming termini con il marcatore data: [DONE] descritto nella documentazione di BroadNet, che la concorrenza concordata giri senza 429 e che un ID di modello sbagliato venga rifiutato.

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())

L’abbiamo eseguito contro un server mock locale (nessun endpoint reale) che consente 8 richieste in corso. Con AGREED_CONCURRENCY=8 tutti e quattro i controlli sono passati. Con 12, il controllo di concorrenza è fallito con otto 200 e quattro 429: è il risultato che vuoi vedere prima del lancio, non dopo. max_tokens=1000 lascia spazio ai modelli di ragionamento, che spendono parte del budget prima di rispondere.

Dopo lo smoke test, esegui un breve test di carico al tuo picco misurato con prompt di dimensioni reali, e registra il tempo al primo token e la latenza della risposta completa dell’endpoint. Conserva i request ID; la documentazione di BroadNet chiede X-Request-ID, timestamp, route e stato nelle richieste di supporto.

Dove si inserisce BroadNet Inference

BroadRouter è il sito di BroadNet. BroadNet Inference vende accesso self-service ai modelli pubblici per token, per minuto di audio, con piani a sessione e con chiavi orarie; i prezzi sono nella pagina prezzi. Endpoint privati, elaborazione regionale, fine-tune e modelli indicati “on request” (su richiesta) non sono self-service: sono richieste per cui BroadNet fa un preventivo e che concorda per iscritto. Questo articolo non può dirti che cosa BroadNet offrirà per il tuo carico di lavoro. Un brief chiaro è il modo per scoprirlo.

Domande frequenti

Che cos’è un endpoint LLM privato?

Un endpoint API basato su capacità riservata a un solo cliente, invece che condivisa con tutti gli utenti self-service. BroadNet descrive la sua versione come una GPU o un nodo riservato con il modello che scegli, chiave e limiti tuoi e la regione che ti serve, raggiungibile con un ID di modello privato.

Come stimo la concorrenza che mi serve?

Usa la legge di Little: richieste concorrenti = richieste al secondo nel picco × secondi per richiesta. 1,67 richieste al secondo da circa 5,8 secondi ciascuna significano circa 10 richieste in corso. Misura i secondi per richiesta sul modello reale con i tuoi prompt reali.

Posso acquistare un endpoint privato BroadNet in self-service?

No. BroadNet presenta endpoint privati, elaborazione regionale e modelli non in elenco come richieste di informazioni: descrivi il carico di lavoro e BroadNet fa un preventivo. I suoi Termini dicono che endpoint privati e capacità riservata seguono un accordo scritto separato.

Un endpoint privato include uno SLA?

Solo se il tuo accordo scritto lo prevede. I Termini di BroadNet dicono che il self-service non ha impegni di disponibilità e che i livelli di servizio esistono solo in un accordo scritto separato. Chiedi i termini esatti prima di farci affidamento.

Dove verranno elaborati i miei dati?

Concordalo prima di inviare dati. I Termini di BroadNet chiedono ai clienti con requisiti di residenza di concordare prima i luoghi di elaborazione, e dicono che l’elaborazione ospitata da partner e quella di backup coinvolgono altri responsabili del trattamento, con un elenco dei sub-responsabili disponibile ai clienti su richiesta.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity