---
title: "Você precisa de fine-tuning no seu LLM? Um checklist"
description: "Quando prompt, RAG ou avaliação resolvem o problema sem fine-tuning, de quais dados de treino você precisa e como testar um fine-tune antes de pedir um."
url: https://broadrouter.com/pt/blog/fine-tuning-readiness/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/fine-tuning-readiness/) (atualizado em 2026-11-16).

# Antes do fine-tuning: defina o problema a resolver

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Faça fine-tuning só depois que uma avaliação mostrar uma falha recorrente que prompts melhores, exemplos, retrieval e validação não resolveram. Conhecimento ausente geralmente pede retrieval, e erros de formato pedem saída estruturada e checagens. Antes de pedir um modelo personalizado, reúna exemplos rotulados que você pode usar legalmente, separe um conjunto de teste e anote a pontuação a superar.

## Pontos principais

-   Comece com um conjunto de avaliação. Sem uma pontuação de referência, não dá para saber se um fine-tune ajudou.
-   Fatos ausentes ou que mudam são um problema de retrieval. O fine-tuning ensina comportamento e estilo de forma mais confiável do que ensina fatos que mudam.
-   O próprio guia da OpenAI coloca avaliações e engenharia de prompt antes do fine-tuning, e diz que o prompting "may be all you need" (tradução: "pode ser tudo de que você precisa").
-   Dados de treino exigem direitos de uso, consistência e um conjunto de teste separado que nunca apareça no treino. Um script curto pega duplicatas, contradições e vazamentos.
-   A API self-service da BroadNet não tem endpoint de fine-tuning. Os fine-tunes em árabe dela são oferecidos sob demanda, em um endpoint privado com um ID de modelo privado.

**Nesta página**

1.  Que problema você está tentando resolver?
2.  Como provar que a falha é recorrente?
3.  Quais mudanças mais simples você deve testar primeiro?
4.  De quais dados você precisa, e você tem o direito de usá-los?
5.  Como avaliar um fine-tune de forma justa?
6.  O que muda quando você não pode fazer fine-tuning de modelos hospedados?
7.  Onde a BroadNet Inference entra

O fine-tuning costuma ser a primeira solução que as pessoas procuram quando um modelo erra algo, e muitas vezes é a errada. Ele custa coleta de dados, rotulagem, rodadas de treino e um modelo que agora você precisa manter. Muitas falhas desaparecem com um prompt mais claro, o retrieval do documento certo ou uma checagem no código sobre a saída. Este post ajuda a decidir em qual caso você está, e o que preparar se realmente precisar de um modelo personalizado.

## Que problema você está tentando resolver?

Dê nome à falha antes de dar nome à solução. A maioria das falhas de LLM cai em alguns padrões, e cada um tem um primeiro passo mais barato:

| Sintoma | Tente primeiro | O fine-tuning ajuda quando |
| --- | --- | --- |
| Fatos errados ou desatualizados | [Retrieval (RAG)](https://broadrouter.com/pt/glossary/rag/) sobre os seus documentos | Raramente; fatos que mudam precisam de retrieval de qualquer jeito |
| Formato errado, JSON quebrado | [Saída estruturada](https://broadrouter.com/pt/glossary/structured-output/), checagens de esquema, uma retentativa | O formato é incomum e exemplos no prompt não bastam |
| Rótulos ou categorias inconsistentes | Definições claras e [exemplos few-shot](https://broadrouter.com/pt/glossary/few-shot-prompting/) | O conjunto de rótulos é grande ou sutil e os exemplos não cabem no prompt |
| Tom ou estilo errado | Um guia de estilo no [prompt de sistema](https://broadrouter.com/pt/glossary/system-prompt/), com exemplos | Um estilo da casa precisa se manter em milhares de saídas |
| Termos do domínio ouvidos ou escritos errado | Uma lista de vocabulário no prompt, pós-correção no código | Modelos de fala erram repetidamente os mesmos nomes, códigos ou números |
| Lento ou caro demais em escala | Um modelo menor, [prompt caching](https://broadrouter.com/pt/blog/prompt-structure-for-caching/), prompts mais curtos | Um modelo pequeno com fine-tuning pode igualar um grande em uma tarefa restrita |
| Idioma ou dialeto errado | Instruções no idioma certo; veja [engenharia de prompt em árabe](https://broadrouter.com/pt/blog/arabic-prompt-engineering/) | O modelo entende, mas não escreve no dialeto de que você precisa |

O próprio guia da OpenAI descreve a mesma ordem: primeiro escreva avaliações, depois itere nos prompts, e use fine-tuning para alguns casos de uso. Ele diz que o processo de engenharia de prompt “may be all you need in order to get great results.” (tradução: “pode ser tudo de que você precisa para obter ótimos resultados”). E lista o que o fine-tuning acrescenta ao prompting: mais exemplos do que cabem em um prompt, prompts mais curtos que economizam tokens, treino com dados que você não quer enviar em toda requisição e deixar um modelo menor bom em uma tarefa.

## Como provar que a falha é recorrente?

Com um conjunto de avaliação. Reúna de 100 a 200 entradas reais com saídas corretas conhecidas, como em [avaliar um LLM antes de trocar](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/). Pontue o seu prompt atual. Depois rotule cada falha com uma categoria curta: `wrong_label`, `missing_field`, `dialect`, `hallucinated_fact` e assim por diante.

Um padrão só é candidato a fine-tuning se as três condições forem verdadeiras:

1.  **É frequente.** Responde por uma parcela relevante das falhas, não por um ou dois casos esquisitos.
2.  **Sobrevive às soluções baratas.** Você tentou instruções mais claras, exemplos, retrieval e validação, e a categoria continua lá.
3.  **É consistente.** As pessoas concordam sobre a resposta certa. Se dois dos seus próprios revisores rotulam o mesmo caso de formas diferentes, um modelo treinado com esses rótulos vai aprender a discordância.

Registre o resultado em uma frase curta, como neste exemplo inventado: “No nosso conjunto de suporte em árabe com 200 casos, o melhor prompt rotula 18% dos tickets de cobrança como entrega; exemplos few-shot reduzem isso para 15%.” Essa frase é o briefing de um fine-tune, e o número a superar.

## Quais mudanças mais simples você deve testar primeiro?

Rode-as em ordem de custo e pontue de novo depois de cada uma:

1.  **Instruções.** Defina cada rótulo ou campo. Diga o que fazer em caso de dúvida.
2.  **Exemplos.** Acrescente de três a dez exemplos reais, incluindo os casos difíceis.
3.  **Retrieval.** Se as respostas precisam de fatos, recupere o trecho relevante. [Busca RAG em árabe](https://broadrouter.com/pt/blog/arabic-rag-search/) e [contexto longo vs RAG](https://broadrouter.com/pt/blog/long-context-vs-rag/) cobrem as escolhas.
4.  **Restrições.** Use saída estruturada quando o modelo suportar e confira a saída no código. Peça de novo uma vez, informando o erro.
5.  **Outro modelo.** Um modelo base diferente pode já fazer o que você precisa. O mesmo conjunto de avaliação mostra isso em uma hora.

Cada passo custa horas, não semanas, e cada um deixa uma referência melhor para um fine-tune superar, se você ainda precisar de um.

## De quais dados você precisa, e você tem o direito de usá-los?

Antes da qualidade, verifique os direitos. Dados de treino muitas vezes vêm de conversas com clientes, documentos ou gravações de chamadas. Você precisa de uma base legal e, muitas vezes, de consentimento ou de uma cláusula contratual que cubra o treino. Confira o seu próprio aviso de privacidade e os contratos com clientes, e remova dados pessoais de que você não precisa. Não presuma que o seu provedor de API está coletando isso por você: a declaração de privacidade da BroadNet, por exemplo, diz que ela não retém o conteúdo da inferência e não usa dados de inferência para treinar, fazer fine-tuning ou avaliar modelos.

Depois verifique a qualidade. Este script lê um arquivo de treino e um arquivo de avaliação no formato JSONL de chat mais comum (um `{"messages": [...]}` por linha, terminando com a resposta do assistente) e aponta problemas que estragam fine-tunes em silêncio: linhas quebradas, duplicatas, a mesma entrada com respostas diferentes, itens de avaliação que vazaram para o treino, equilíbrio de rótulos e possíveis dados pessoais.

```python
import json, re, sys
from collections import Counter

DIAC = re.compile(r"[ً-ٰٟـ]")          # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
       "phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}

def norm(s: str) -> str:
    s = DIAC.sub("", s.lower())
    s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
    return " ".join(s.split())

def load(path):
    rows, errors = [], []
    for i, line in enumerate(open(path, encoding="utf-8"), 1):
        try:
            ex = json.loads(line)
            roles = [m["role"] for m in ex["messages"]]
            if roles[-1] != "assistant" or "user" not in roles:
                raise ValueError(f"roles {roles}")
            rows.append(ex)
        except (ValueError, KeyError, IndexError, TypeError) as e:
            errors.append(f"line {i}: {e}")
    return rows, errors

def key(ex):     # the input side, normalised: what the model sees
    return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))

def check(train_path, eval_path):
    train, errs = load(train_path)
    evals, eval_errs = load(eval_path)
    keys = Counter(key(e) for e in train)
    labels = Counter(e["messages"][-1]["content"].strip() for e in train)
    leaked = {key(e) for e in evals} & set(keys)
    pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
    conflicts = Counter()
    seen = {}
    for e in train:
        k, a = key(e), e["messages"][-1]["content"].strip()
        if k in seen and seen[k] != a:
            conflicts[k] += 1
        seen.setdefault(k, a)
    return {"train_examples": len(train), "parse_errors": errs + eval_errs,
            "duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
            "same_input_different_answer": len(conflicts),
            "eval_items_also_in_train": len(leaked),
            "answer_distribution": labels.most_common(5),
            "examples_with_possible_pii": dict(pii)}

if __name__ == "__main__":
    print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))
```

Rodamos o script em um arquivo de brinquedo de sete linhas com tickets de suporte em árabe, inglês e espanhol. Ele encontrou uma linha sem resposta do assistente, duas entradas duplicadas (uma diferia só por um diacrítico, que o normalizador remove, como em [normalização de texto em árabe](https://broadrouter.com/pt/blog/arabic-text-normalization-search/)), uma entrada rotulada como `billing` e também como `other`, um item de avaliação que também aparecia no treino e um número de telefone. Qualquer um deles faria o fine-tune parecer melhor ou pior do que é.

A normalização importa para o árabe. Sem ela, “متأخر” e “متأخِّر” contam como entradas diferentes, e uma quase cópia de um item de teste pode escapar para o treino.

## Como avaliar um fine-tune de forma justa?

Use o mesmo conjunto de teste separado que você usou na referência, e mantenha-o fora do treino. Depois compare:

-   **Com o melhor prompt, não com o primeiro.** Um fine-tune que vence um prompt fraco não prova nada.
-   **Por categoria e por idioma.** Um ganho geral pode esconder uma queda no árabe enquanto o inglês melhora. Reporte cada um.
-   **No comportamento geral.** Acrescente de 20 a 50 pedidos comuns que o modelo já resolvia bem. Um treino estreito pode piorar o comportamento fora da tarefa.
-   **Em custo e latência.** Um fine-tune muitas vezes se justifica por um modelo menor fazer o trabalho. Meça também tokens e tempo por requisição.

Decida a regra de aprovação antes de ver os números, como no post sobre avaliação: por exemplo, “pelo menos 5 pontos melhor nos rótulos de cobrança, nenhuma categoria pior em mais de 2 pontos, árabe e inglês aprovados”.

## O que muda quando você não pode fazer fine-tuning de modelos hospedados?

Menos APIs hospedadas oferecem fine-tuning self-service do que você imagina. A página de descontinuações da OpenAI registra uma atualização na sua plataforma de fine-tuning self-service: desde 7 de maio de 2026, organizações que nunca tinham rodado fine-tuning não podem mais criar jobs; desde 2 de julho de 2026, também não podem as organizações que não tinham rodado inferência num modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027 clientes ativos existentes não poderão mais criar novos jobs de fine-tuning. Modelos já ajustados continuam disponíveis para inferência até que seus modelos base sejam descontinuados.

A alternativa habitual é um [modelo open-weight](https://broadrouter.com/pt/glossary/open-weight-model/) treinado com um método eficiente em parâmetros como o [LoRA](https://broadrouter.com/pt/glossary/lora/). O artigo do LoRA (Hu et al.) relata que, em comparação com o fine-tuning completo do GPT-3 175B com Adam, o LoRA pode reduzir o número de parâmetros treináveis em 10.000 vezes e a memória de GPU necessária em 3 vezes. Depois você precisa de um lugar para servir o resultado: o seu próprio hardware ou um provedor que hospede pesos personalizados. [Modelos open-weight vs fechados](https://broadrouter.com/pt/blog/open-weight-vs-closed-models/) trata desse trade-off.

## Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. A API self-service da BroadNet Inference não tem endpoint de fine-tuning: sua [referência da API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fine-tuning-readiness&utm_content=body) documenta apenas chat completions e transcrição de áudio. A mesma página 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 em árabe e outros modelos sob demanda são acessados com um ID privado emitido junto com o endpoint”). As páginas de modelo da BroadNet listam um fine-tune da BroadNet do Cohere Transcribe Arabic para números, datas e nomes em áudio ruidoso como disponível sob demanda, com um ID de modelo privado por cliente, e dizem que o Gemma 4 VL 26B está disponível em um endpoint privado “including our Arabic fine-tunes” (tradução: “incluindo nossos fine-tunes em árabe”). São consultas feitas pela [página de contato](https://broadrouter.com/pt/contact/#private), não algo que você possa comprar ou treinar por conta própria; [planejar um endpoint privado](https://broadrouter.com/pt/blog/private-endpoint-planning/) explica o que enviar.

Para tudo antes dessa etapa, os modelos públicos bastam para montar o seu conjunto de avaliação e a referência: [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) e [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) documentam saída estruturada, o [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) roda com o crédito inicial de $5 e o [BroadNet Transcribe Arabic](https://broadrouter.com/pt/models/cohere-transcribe-arabic/) cuida da fala a $0.0042 por minuto. O conteúdo da 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 da BroadNet.

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Fine-tuning (ajuste fino de LLM)](https://broadrouter.com/pt/glossary/fine-tuning/)

Fine-tuning é o processo de continuar treinando um modelo de linguagem pré-treinado com um conjunto de dados menor e específico, como conversas de exemplo, para que seus pesos mudem e ele execute aquela tarefa ou estilo de forma mais confiável, sem instruções longas ou exemplos em todo prompt.

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[LoRA (low-rank adaptation)](https://broadrouter.com/pt/glossary/lora/)

LoRA (low-rank adaptation, adaptação de baixo posto) é um método de fine-tuning eficiente em parâmetros que congela os pesos de um modelo pré-treinado e treina um par de pequenas matrizes de baixo posto para camadas escolhidas. A atualização aprendida pode ser guardada como um pequeno adapter ou mesclada aos pesos, sem adicionar latência na inferência.

[Eval (avaliação de LLM)](https://broadrouter.com/pt/glossary/eval/)

Uma eval (abreviação de evaluation, avaliação) é um teste repetível de um modelo de linguagem ou de um prompt: um conjunto fixo de entradas, uma descrição de como é uma boa saída e um avaliador (código, uma pessoa ou outro modelo) que pontua cada saída, para que versões possam ser comparadas.

[Saída estruturada (structured output)](https://broadrouter.com/pt/glossary/structured-output/)

Saída estruturada é um recurso de APIs de LLM que restringe a resposta de um modelo a um formato definido pelo desenvolvedor, normalmente um JSON Schema, para que o código consiga interpretá-la de forma confiável. É mais rigorosa que o JSON mode, que garante um JSON válido, mas não uma estrutura específica.

[Engenharia de prompt (prompt engineering)](https://broadrouter.com/pt/glossary/prompt-engineering/)

Engenharia de prompt é o processo de escrever, estruturar e testar as instruções dadas a um modelo de linguagem para que ele produza, de forma consistente, uma saída que atenda aos seus requisitos. Inclui mensagens de papel, instruções claras, exemplos, formatação e a medição dos resultados com casos de teste.

[Chat Completions API](https://broadrouter.com/pt/glossary/chat-completions-api/)

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

[Fala para texto (speech-to-text)](https://broadrouter.com/pt/glossary/speech-to-text/)

Fala para texto, ou reconhecimento automático de fala (ASR), é a tecnologia que converte áudio falado em texto. Uma API de fala para texto recebe um arquivo ou stream de áudio e retorna uma transcrição, normalmente cobrada por minuto de áudio. A precisão é medida pela taxa de erro de palavras e varia com sotaque, dialeto e qualidade da gravação.

## Perguntas frequentes

### Devo fazer fine-tuning ou usar RAG?

Use retrieval quando faltam fatos ao modelo, principalmente fatos que mudam: documentos, preços, políticas. Considere fine-tuning quando o modelo tem a informação, mas se comporta errado de forma consistente, como em formato, tom, rótulos ou vocabulário do domínio, e prompts com exemplos não resolveram.

### Como sei se a engenharia de prompt é suficiente?

Meça. Monte um conjunto de avaliação com entradas reais, pontue o prompt atual e depois teste instruções mais claras, exemplos few-shot, saída estruturada e validação. Se a pontuação atingir a meta, pare. Se um tipo de falha persistir em todas essas mudanças, ele é candidato a fine-tuning.

### Quantos dados preciso para fazer fine-tuning?

Não existe um número universal. Depende da tarefa, do modelo base e do método. Reúna exemplos rotulados e consistentes em quantidade suficiente para cobrir todos os casos que importam, mais um conjunto de teste separado, e confira se a pontuação continua subindo conforme você acrescenta dados.

### Posso fazer fine-tuning de um modelo na BroadNet Inference?

Não em self-service. A referência da API da BroadNet documenta chat completions e transcrição de áudio, sem endpoint de treino. A BroadNet lista fine-tunes em árabe, como um Cohere Transcribe Arabic ajustado, como modelos sob demanda servidos em um endpoint privado com um ID de modelo privado.

### A BroadNet treina com o meu tráfego de API?

A declaração de privacidade da BroadNet diz que ela não usa dados de inferência para treinar, fazer fine-tuning ou avaliar modelos, e não retém o conteúdo da inferência. Se você quiser fazer fine-tuning com o seu tráfego, precisa coletar e guardar esses dados por conta própria, com o direito de usá-los.

## Continue lendo

-   [Como avaliar um LLM antes de trocar de provedor](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/)
-   [Engenharia de prompt em árabe: registro, RTL, números e texto misto](https://broadrouter.com/pt/blog/arabic-prompt-engineering/)
-   [RAG em árabe: normalização, chunking e retrieval que funcionam](https://broadrouter.com/pt/blog/arabic-rag-search/)
-   [Contexto longo vs RAG: quando 1M de tokens substitui um banco vetorial](https://broadrouter.com/pt/blog/long-context-vs-rag/)
-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [IA open-weight vs fechada na empresa: custo, controle e risco](https://broadrouter.com/pt/blog/open-weight-vs-closed-models/)
-   [Um endpoint privado começa com uma carga de trabalho clara](https://broadrouter.com/pt/blog/private-endpoint-planning/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: API de transcrição de áudio em árabe, passo a passo](https://broadrouter.com/pt/guides/arabic-speech-to-text-api/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fine-tuning-readiness&utm_content=page-cta) ·

**Fontes**

-   [OpenAI, guia de otimização de modelos: avaliações, engenharia de prompt e fine-tuning (consultado em 2026-11-15)](https://platform.openai.com/docs/guides/fine-tuning)
-   [OpenAI, Deprecations: atualização do fine-tuning self-service, com datas de 7 de maio de 2026, 2 de julho de 2026 e 6 de janeiro de 2027 (consultado em 2026-11-15)](https://platform.openai.com/docs/deprecations)
-   [Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, arXiv 2106.09685 (consultado em 2026-11-15)](https://arxiv.org/abs/2106.09685)
-   [Referência da API da BroadNet Inference: endpoints, e "our Arabic fine-tunes" acessados com um ID privado (consultada em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fine-tuning-readiness&utm_content=sources)
-   [Página de modelo da BroadNet, fine-tune da BroadNet do Cohere Transcribe Arabic: sob demanda, ID privado por cliente (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference/models/cohere-transcribe-arabic-broadnet)
-   [Página de modelo da BroadNet, Gemma 4 VL 26B: endpoint privado "including our Arabic fine-tunes" (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference/models/gemma-4-vl-26b)
-   [Declaração de privacidade da BroadNet Inference: dados de inferência não são usados para treinar, fazer fine-tuning ou avaliar modelos (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference-privacy)
