---
title: "Fila de revisão humana para IA de documentos: regras"
description: "Revisão humana em um pipeline de IA para documentos: regras de validação, o que mandar a uma pessoa, amostras aleatórias, trilha de auditoria e taxa de revisão."
url: https://broadrouter.com/pt/blog/document-review-queues/
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/document-review-queues/) (atualizado em 2026-11-16).

# Revisão humana no seu fluxo de IA para documentos

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

Trate todo documento extraído como não aprovado até que passe nas regras. Mande para uma pessoa quando faltar um campo obrigatório, as somas não baterem, a data ou o fornecedor parecerem errados ou o modelo estiver inseguro. Revise também uma pequena parcela aleatória de documentos limpos, registre cada correção no seu próprio sistema e acompanhe a taxa de revisão e a taxa de erro auditada.

## Pontos principais

-   São as regras de validação que decidem o que uma pessoa vê. A confiança declarada pelo próprio modelo é só mais um sinal, e pesquisas publicadas mostram que LLMs são confiantes demais quando a declaram.
-   Todo documento na fila deve trazer motivos legíveis por máquina, como arithmetic ou vendor:unknown, para que o revisor saiba onde olhar e você saiba qual regra corrigir.
-   Audite uma amostra aleatória dos documentos aprovados automaticamente. Zero erros em 50 documentos auditados ainda permite uma taxa de erro real de até cerca de 7% (intervalo de Wilson de 95%).
-   Mantenha você mesmo a trilha de auditoria: hash da imagem, ID do modelo, versão do prompt, saída, regras acionadas e a correção do revisor. Uma API com retenção zero não guarda nenhuma cópia do conteúdo.
-   Acompanhe três números toda semana: taxa de revisão, principais motivos de revisão e taxa de erro auditada dos documentos aprovados automaticamente.

**Nesta página**

1.  O que deve decidir se uma pessoa revisa um documento?
2.  Dá para confiar na confiança do modelo?
3.  Como encaminhar documentos para uma fila?
4.  O que muda com faturas em árabe e inglês?
5.  O que o revisor deve ver?
6.  Por que amostrar documentos que passaram em todas as regras?
7.  Como manter uma trilha de auditoria?
8.  Como medir a taxa de revisão?
9.  Onde a BroadNet Inference entra

Um modelo de visão consegue ler uma fatura, mas também pode ler um dígito errado, pular uma linha ou inventar um campo que não existe. A solução não é só um prompt melhor. É uma etapa de revisão pensada desde o primeiro dia: regras que decidem quais documentos uma pessoa vê, uma fila que explica o porquê e um log que permite provar a taxa de erro.

Este post trata dessa etapa. A extração em si (preparo da imagem, prompt JSON, validação de esquema e retentativas) está em [extrair dados de documentos com um LLM de visão](https://broadrouter.com/pt/blog/extract-data-from-documents-with-vision-llm/), e a leitura específica do árabe está em [ler faturas em árabe com visão](https://broadrouter.com/pt/guides/read-arabic-invoices-with-vision/). Aqui partimos do princípio de que você já recebe JSON e precisa decidir em que confiar.

## O que deve decidir se uma pessoa revisa um documento?

Regras que você consegue testar no código, não uma impressão sobre o modelo. Comece por estas, em ordem de valor:

| Regra | Exemplo de código de motivo | Por que importa |
| --- | --- | --- |
| Campo obrigatório ausente | `missing:total` | Um null é honesto; um valor chutado é pior |
| Somas não batem | `arithmetic:subtotal+tax!=total` | Um único dígito mal lido quase sempre quebra uma soma |
| Itens não somam | `arithmetic:lines!=subtotal` | Pega linhas puladas ou duplicadas |
| Data ilegível ou fora do intervalo | `date:unparsed` | Pega dia e mês trocados e ruído de OCR |
| ID fiscal do fornecedor desconhecido | `vendor:unknown` | Fornecedores novos e fraudes começam aqui |
| Moeda inesperada | `currency:unexpected` | Um símbolo mal lido muda o valor |
| O modelo diz que não tem certeza | `model:not_confident` | Um indício, nunca o único filtro |

Duas decisões de design tornam a fila utilizável. Primeiro, cada regra gera um código de motivo curto e estável, então o revisor abre o documento sabendo o que conferir, e você consegue contar qual regra dispara mais. Segundo, um documento ou passa em todas as regras ou vai para uma pessoa. Evite pontuações ponderadas que ninguém consegue explicar a um auditor.

## Dá para confiar na confiança do modelo?

Trate-a como um sinal fraco. Você pode pedir ao modelo que avalie cada campo com confiança alta, média ou baixa, e ele fará isso. Mas Xiong et al. (ICLR 2024) compararam formas de fazer LLMs declararem confiança e concluíram que os modelos “tend to be overconfident” (tradução: “tendem a ser confiantes demais”) quando dizem o quanto estão seguros; prompts e amostragem melhores ajudaram, e nenhum método superou os outros de forma consistente. Em algumas APIs, log-probabilidades de tokens são outra opção. A referência da API da BroadNet não documenta `logprobs`, então não projete em cima delas lá.

A regra prática: qualquer coisa abaixo de “high” vinda do modelo, ou a falta de avaliação, manda o documento para revisão, mas um “high” nunca pula as checagens no código. Depois de algumas centenas de documentos revisados, confira se os campos “high” realmente tiveram menos correções. Se não tiveram, descarte o sinal.

## Como encaminhar documentos para uma fila?

Este roteador roda depois da extração e da validação. Ele normaliza os dígitos arábico-índicos, aplica as regras acima e escolhe uma de três filas: `review`, `audit_sample` ou `auto`. É Python puro, sem chamada de API, então dá para escrever testes unitários.

```python
import hashlib, json, random, re, time
from datetime import date, datetime
from decimal import Decimal, InvalidOperation

REQUIRED = ["vendor_name", "invoice_number", "invoice_date", "currency", "subtotal", "tax", "total"]
CURRENCIES = {"SAR", "AED", "USD", "EUR"}
KNOWN_VENDORS = {"300000000000003": "Example Trading Co"}   # your supplier master: tax ID -> name
AUTO_SAMPLE_RATE = 0.05          # share of clean documents a person still checks
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹٫٬", "01234567890123456789.,")

def money(v):
    """'١٬٢٥٠٫٥٠' or '1,250.50' -> Decimal('1250.50'); None if it is not a number."""
    if v is None:
        return None
    s = str(v).translate(DIGITS).replace(",", "").strip()
    try:
        return Decimal(s)
    except InvalidOperation:
        return None

def check(doc: dict, today: date) -> list[str]:
    """Return the reasons this document needs a person. Empty list = may auto-approve."""
    reasons = [f"missing:{f}" for f in REQUIRED if doc.get(f) in (None, "")]
    sub, tax, tot = (money(doc.get(k)) for k in ("subtotal", "tax", "total"))
    if None not in (sub, tax, tot) and abs(sub + tax - tot) > Decimal("0.01"):
        reasons.append("arithmetic:subtotal+tax!=total")
    lines = [money(l.get("amount")) for l in doc.get("lines", [])]
    if lines and None not in lines and sub is not None and abs(sum(lines) - sub) > Decimal("0.01"):
        reasons.append("arithmetic:lines!=subtotal")
    try:
        d = datetime.strptime(str(doc.get("invoice_date", "")).translate(DIGITS), "%Y-%m-%d").date()
        if d > today or (today - d).days > 400:
            reasons.append("date:out_of_range")
    except ValueError:
        reasons.append("date:unparsed")
    if doc.get("currency") and doc["currency"] not in CURRENCIES:
        reasons.append("currency:unexpected")
    if doc.get("vendor_tax_id") not in KNOWN_VENDORS:
        reasons.append("vendor:unknown")
    if doc.get("model_confidence", "low") != "high":   # a hint from the prompt, never the only gate
        reasons.append("model:not_confident")
    return reasons

def route(doc_id: str, doc: dict, today: date, rng=random.random) -> dict:
    reasons = check(doc, today)
    if reasons:
        queue = "review"
    elif rng() < AUTO_SAMPLE_RATE:
        queue, reasons = "audit_sample", ["sample:random"]
    else:
        queue = "auto"
    return {"doc": hashlib.sha256(doc_id.encode()).hexdigest()[:16], "queue": queue,
            "reasons": reasons, "ts": int(time.time())}
```

Testamos com três faturas sauditas inventadas (o fornecedor e o ID fiscal são fictícios). Uma limpa, com a data e o subtotal escritos em dígitos arábico-índicos (٢٠٢٦-١١-٠٢ e ١٬٠٠٠٫٠٠), foi para `auto`. A mesma fatura com o total lido errado como 1,105.00 foi para `review` com `arithmetic:subtotal+tax!=total`. Uma com ID fiscal desconhecido, mês 13 e confiança “medium” foi para `review` com três motivos: `date:unparsed`, `vendor:unknown` e `model:not_confident`. Forçar o sorteio aleatório abaixo de 0,05 mandou a fatura limpa para `audit_sample`.

Dois limites a conhecer. O helper `money()` assume ponto ou o separador decimal árabe; um valor no formato europeu como “1.150,00” precisa de um parser próprio, escolhido pelo país do fornecedor. E a regra de data assume que o modelo devolveu datas ISO. Datas do calendário hegírico precisam ser convertidas antes, como em [extração de entidades nomeadas em árabe](https://broadrouter.com/pt/blog/arabic-named-entity-extraction-llm/).

## O que muda com faturas em árabe e inglês?

Faturas bilíngues são comuns no Golfo: rótulos em árabe e inglês lado a lado, valores em dígitos ocidentais ou arábico-índicos e o nome do fornecedor em dois alfabetos. Algumas regras ajudam:

-   **Normalize os dígitos antes de qualquer checagem.** Converta ٠–٩ e os persas ۰–۹ para 0–9, e os separadores árabes de decimal e milhar (٫ e ٬) para suas formas ASCII. Depois compare.
-   **Associe fornecedores pelo ID fiscal, não pelo nome.** Os nomes em árabe e inglês raramente batem caractere por caractere com o seu cadastro. O número de registro bate.
-   **Mostre os dois nomes ao revisor.** Exiba os nomes do fornecedor extraídos em árabe e inglês ao lado do registro do cadastro, com o árabe em um bloco isolado da direita para a esquerda. O post sobre [design de produtos multilíngues](https://broadrouter.com/pt/blog/multilingual-product-design/) explica a exibição bidirecional.
-   **Verifique se existe uma fatura estruturada.** Na Arábia Saudita, a ZATCA opera o faturamento eletrônico (Fatoorah) em duas fases, a partir de 4 de dezembro de 2021 e de 1º de janeiro de 2023, baseado em faturas em formato eletrônico estruturado. Se um fornecedor pode enviar isso, faça o parsing do arquivo em vez de ler uma foto dele, e deixe a visão para papel, fotos e a cauda longa.

[OCR de árabe com um LLM de visão](https://broadrouter.com/pt/blog/arabic-ocr-vision-llm/) cobre o lado da leitura: diacríticos, escritas mistas e layout.

## O que o revisor deve ver?

Uma boa tela de revisão responde a uma pergunta por código de motivo. Para `arithmetic`, mostre itens, subtotal, imposto e total lado a lado com a soma calculada. Para `vendor:unknown`, mostre o ID fiscal extraído e os registros mais próximos do cadastro. Para `date:unparsed`, mostre o texto bruto da data e o recorte da imagem de onde ele veio.

Mostre a imagem ao lado dos campos, não em outra aba. Deixe o revisor corrigir um campo, aprovar ou rejeitar o documento como ilegível. Registre qual ação ele tomou. “Ilegível” é um dado útil: se 10% dos documentos de um fornecedor são ilegíveis, peça PDFs a esse fornecedor, não um milagre ao seu modelo.

## Por que amostrar documentos que passaram em todas as regras?

Porque as regras só pegam os erros em que você pensou. Se um modelo lê errado um item, o subtotal e o total pelo mesmo valor (um 7 borrado lido como 1 nos três lugares), todas as somas continuam batendo e nenhuma regra dispara. A única forma de encontrar esses erros é olhar documentos que ninguém sinalizou.

Amostre ao acaso, não por escolha, e conte quantos precisaram de correção. Uma amostra pequena dá uma faixa ampla. Com o intervalo de Wilson de 95%, que o manual do NIST descreve para proporções (citando recomendações de Agresti e Coull, e de Brown, Cai e DasGupta), o nosso código de métricas abaixo dá:

| Documentos auditados sem nenhum erro encontrado | A taxa de erro real ainda pode chegar a |
| --- | --- |
| 50 | cerca de 7,1% |
| 300 | cerca de 1,3% |

Ou seja, “auditamos 50 e não achamos nada” não significa que a taxa de erro está abaixo de 1%. Aumente a amostra depois de qualquer mudança no prompt, no modelo ou no tipo de documentos, e reduza devagar.

## Como manter uma trilha de auditoria?

Registre as correções no seu próprio sistema. Cada documento precisa de uma linha com:

-   um hash SHA-256 do arquivo de origem (e onde o próprio arquivo está armazenado, sob suas regras de retenção);
-   o ID do modelo, a versão do prompt e o JSON bruto que o modelo devolveu;
-   o ID da requisição do provedor (a BroadNet o devolve no header `X-Request-ID`) para chamados de suporte;
-   os resultados das regras e a fila;
-   o revisor, o horário, a ação e o valor antes e depois de cada campo corrigido.

Isso importa ainda mais com uma API de retenção zero. A declaração de privacidade da BroadNet diz que seu gateway não guarda prompts, imagens, respostas nem transcrições, e mantém apenas registros de conta, cobrança, tráfego e segurança sem conteúdo. Isso é bom para faturas sensíveis, mas significa que ninguém no provedor pode mostrar o que o modelo viu ou disse no mês passado. O seu log é o único registro. Mantenha-o livre de tudo o que você não precisa; [log de uso de APIs de LLM](https://broadrouter.com/pt/blog/llm-api-usage-logging/) explica o que registrar e o que ocultar.

## Como medir a taxa de revisão?

Rode isto toda semana sobre o log de roteamento, com as correções incorporadas:

```python
import math
from collections import Counter

def wilson(errors: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """95% Wilson score interval for an error rate seen in a sample."""
    if n == 0:
        return (0.0, 1.0)
    p = errors / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return (max(0.0, centre - half), min(1.0, centre + half))

def report(log: list[dict]) -> dict:
    queues = Counter(r["queue"] for r in log)
    reasons = Counter(x.split(":")[0] for r in log if r["queue"] == "review" for x in r["reasons"])
    audited = [r for r in log if r["queue"] == "audit_sample"]
    wrong = sum(1 for r in audited if r.get("corrected_fields"))
    lo, hi = wilson(wrong, len(audited))
    return {"documents": len(log),
            "review_rate": round(queues["review"] / len(log), 3),
            "top_reasons": reasons.most_common(3),
            "audited": len(audited), "audited_with_errors": wrong,
            "auto_error_rate_95ci": (round(lo, 4), round(hi, 4))}
```

Em uma semana sintética de 1.000 documentos (760 automáticos, 190 em revisão, 50 auditados, dos quais 2 precisaram de correção), ele relatou uma taxa de revisão de 0,19, `vendor` como principal motivo com 120 casos e uma taxa de erro auditada entre 1,1% e 13,5%. Essa última faixa é a resposta honesta para “qual é a precisão da automação?” com esse tamanho de amostra.

Leia os três números juntos:

-   **Taxa de revisão cai, erros auditados ficam estáveis:** uma regra estava rígida demais, ou o modelo melhorou. Ótimo.
-   **Taxa de revisão cai, erros auditados sobem:** uma regra está frouxa demais. Aperte-a antes que os erros cheguem à sua contabilidade.
-   **Um motivo domina:** corrija a causa. Se `vendor:unknown` lidera, atualize o cadastro de fornecedores; se `arithmetic` lidera, veja a qualidade das imagens ou teste outro modelo nos mesmos documentos com o método de [avaliar um LLM antes de trocar](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/).

## Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. Segundo seu [feed de preços](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-document-review-queues&utm_content=body), a BroadNet Inference oferece três modelos de chat que aceitam imagens: [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) ($0.175 de entrada / $2.17 de saída por 1M de tokens, com saída estruturada documentada), [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) ($0.10 / $0.22, utilizável com o crédito inicial de $5) e [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) ($0.175 / $0.52). No pagamento por uso, imagens contam como tokens de entrada; a [calculadora de tokens de imagem](https://broadrouter.com/tools/image-token-calculator/) ajuda a estimá-los. 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](https://www.broadnet.ai/inference-privacy) da BroadNet. A BroadNet não oferece fila de revisão nem log de auditoria, então o roteamento e os registros acima ficam por sua conta construir e manter.

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

[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.

[Modelo de visão e linguagem (VLM)](https://broadrouter.com/pt/glossary/vision-language-model/)

Um modelo de visão e linguagem (VLM, vision-language model) é um modelo que recebe imagens e texto juntos como entrada e produz texto, então consegue descrever fotos, responder perguntas sobre elas e ler documentos, gráficos ou capturas de tela. VLMs também são chamados de modelos image-text-to-text ou multimodais.

[Reconhecimento de entidades nomeadas (NER)](https://broadrouter.com/pt/glossary/named-entity-recognition/)

Reconhecimento de entidades nomeadas (NER) é a tarefa de encontrar nomes em um texto e rotular cada um com um tipo, como pessoa, organização ou local. Sistemas clássicos rotulam cada token; já aos LLMs costuma-se pedir uma lista de entidades em JSON, que depois é conferida contra o texto original.

[Reconhecimento óptico de caracteres (OCR)](https://broadrouter.com/pt/glossary/ocr/)

OCR (reconhecimento óptico de caracteres) é a tecnologia que detecta texto impresso ou manuscrito em uma imagem, digitalização ou PDF e o converte em caracteres legíveis por máquina. O OCR clássico devolve o texto e a posição dele na página; modelos de visão e linguagem conseguem ler o texto e responder perguntas sobre ele diretamente.

[Logprobs (log-probabilidades)](https://broadrouter.com/pt/glossary/logprobs/)

Logprobs são as log-probabilidades que um modelo de linguagem atribuiu aos tokens que gerou. Uma API que os retorna mostra, para cada token de saída, quão provável o modelo o considerou e, opcionalmente, os tokens alternativos mais prováveis naquela posição.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[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.

[Tokens de entrada e de saída](https://broadrouter.com/pt/glossary/input-and-output-tokens/)

Tokens de entrada são os tokens que um modelo de linguagem lê em uma requisição, incluindo o system prompt, o histórico da conversa, as definições de ferramentas e as imagens. Tokens de saída são os que ele gera na resposta, incluindo o raciocínio. As APIs de LLM costumam cobrá-los separadamente, e a saída costuma custar mais.

## Perguntas frequentes

### O que deve ir para revisão humana na extração de notas e faturas?

Tudo o que falhar em uma regra: um campo obrigatório ausente, itens ou imposto que não somam o total, uma data ilegível ou fora do intervalo, um fornecedor desconhecido, uma moeda inesperada ou uma confiança do modelo abaixo de "high". Acrescente uma pequena amostra aleatória de documentos que passaram em todas as regras.

### Posso usar a pontuação de confiança do modelo para pular a revisão?

Não sozinha. A pesquisa sobre confiança declarada (Xiong et al., ICLR 2024) concluiu que LLMs tendem a ser confiantes demais. Use-a como um sinal ao lado das checagens no código e confira nos seus dados rotulados se "high" realmente significa menos erros.

### Quantos documentos aprovados automaticamente devo auditar?

O suficiente para limitar a taxa de erro que importa para você. Sem nenhum erro encontrado, 50 documentos auditados limitam a taxa real a cerca de 7% (limite superior de Wilson de 95%) e 300 a cerca de 1,3%. Aumente a amostra quando uma regra, o prompt ou o modelo mudar.

### Qual é uma boa taxa de revisão?

Não existe um número universal. Comece alto e só reduza quando a taxa de erro auditada dos documentos aprovados automaticamente ficar dentro da sua tolerância. Taxa de revisão caindo com taxa de erro auditada subindo significa que alguma regra está frouxa demais.

### Onde a trilha de auditoria deve ficar?

No seu próprio banco de dados. Guarde um hash do arquivo de origem, o ID do modelo, a versão do prompt, a saída bruta, os resultados das regras, o revisor e os valores corrigidos. Se o seu provedor não retém o conteúdo das requisições, como a BroadNet afirma sobre sua API de inferência, ninguém mais conseguirá reconstruí-lo depois.

## Continue lendo

-   [Extrair dados de faturas, recibos e formulários com LLM de visão](https://broadrouter.com/pt/blog/extract-data-from-documents-with-vision-llm/)
-   [OCR em árabe ou LLM de visão: lendo documentos e notas fiscais](https://broadrouter.com/pt/blog/arabic-ocr-vision-llm/)
-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [Como avaliar um LLM antes de trocar de provedor](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/)
-   [Log de uso de API de LLM: custo por usuário e recurso, sem PII](https://broadrouter.com/pt/blog/llm-api-usage-logging/)
-   [Como corrigir JSON inválido de um LLM: causas, reparo e retry](https://broadrouter.com/pt/blog/fix-invalid-json-from-llm/)
-   [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: Ler notas fiscais e recibos em árabe com um modelo de visão](https://broadrouter.com/pt/guides/read-arabic-invoices-with-vision/)
-   [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-document-review-queues&utm_content=page-cta) ·

**Fontes**

-   [Xiong et al., Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs, ICLR 2024 (consultado em 2026-11-15)](https://arxiv.org/abs/2306.13063)
-   [NIST/SEMATECH e-Handbook of Statistical Methods, 7.2.4: intervalos de confiança para uma proporção, método de Wilson (consultado em 2026-11-15)](https://www.itl.nist.gov/div898/handbook/prc/section2/prc241.htm)
-   [ZATCA, faturamento eletrônico (Fatoorah): fase 1 a partir de 4 de dezembro de 2021, fase 2 a partir de 1º de janeiro de 2023 (consultado em 2026-11-15)](https://zatca.gov.sa/en/E-Invoicing/Pages/default.aspx)
-   [Referência da API da BroadNet Inference: chat com imagem, saída estruturada, X-Request-ID, tratamento de dados (consultada em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-document-review-queues&utm_content=sources)
-   [pricing.json da BroadNet Inference: modalidades e preços dos modelos (consultado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-document-review-queues&utm_content=sources)
-   [Declaração de privacidade e retenção de dados da BroadNet Inference (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference-privacy)
