10 casos de uso de LLM na empresa, com o código e o custo real em reais

"IA na empresa" costuma virar reunião longa e projeto que não sai. Este artigo é o oposto: dez casos de uso concretos, com o código que os resolve e quanto cada um custa em reais por mês, calculado com os preços públicos da nossa API por token. Todos os números foram calculados com a tabela vigente em 15/08/2026 e você pode refazer cada conta.

O resumo, antes do detalhe

Somando tudo: R$ 1.399 por mês para dez automações rodando ao mesmo tempo. É menos que um estagiário — e nenhuma delas exige provisionar servidor.

1. Classificar e rotear tickets — R$ 0,00041 por ticket

Entrada de ~800 tokens (o ticket) e saída de ~20 (a categoria). O modelo mais barato resolve: classificação não pede raciocínio longo, pede consistência.

from openai import OpenAI
from concurrent.futures import ThreadPoolExecutor

cliente = OpenAI(api_key=CHAVE, base_url="https://gpubrasil.com.br/v1")

CATEGORIAS = ["cobranca", "acesso", "bug", "duvida_produto", "cancelamento"]

def classificar(ticket):
    r = cliente.chat.completions.create(
        model="gpub-fast",
        messages=[
            {"role": "system", "content":
             "Classifique o ticket em UMA categoria: " + ", ".join(CATEGORIAS) +
             ". Responda apenas a categoria, sem explicacao."},
            {"role": "user", "content": ticket},
        ],
        temperature=0,
        max_tokens=8,
    )
    return r.choices[0].message.content.strip(), r.usage.cost_brl

# 100 mil tickets em paralelo, com limite de concorrencia
with ThreadPoolExecutor(max_workers=16) as pool:
    resultados = list(pool.map(classificar, tickets))

print("Custo total: R$", round(sum(c for _, c in resultados), 2))

Conta: 80M tokens de entrada × R$ 0,49 = R$ 39,20 · 2M de saída × R$ 1,09 = R$ 2,18 → R$ 41,38.

2. Extrair campos de documento — R$ 0,0028 por documento

Nota fiscal, contrato, laudo, ficha cadastral. O truque é pedir JSON e só JSON, e validar no seu código.

import json

ESQUEMA = """Extraia e responda SOMENTE com JSON valido:
{"fornecedor": str, "cnpj": str, "numero": str, "data": "AAAA-MM-DD",
 "valor_total": number, "itens": [{"descricao": str, "quantidade": number, "valor": number}]}
Se um campo nao existir no documento, use null."""

def extrair(texto_do_documento):
    r = cliente.chat.completions.create(
        model="gpub-mini",
        messages=[
            {"role": "system", "content": ESQUEMA},
            {"role": "user", "content": texto_do_documento},
        ],
        temperature=0,
        max_tokens=800,
    )
    bruto = r.choices[0].message.content.strip()
    bruto = bruto.removeprefix("```json").removeprefix("```").removesuffix("```")
    return json.loads(bruto), r.usage.cost_brl

Para o PDF virar texto antes disso, os templates Marker e Surya OCR rodam numa GPU pequena e lidam bem com português e documento escaneado.

Conta: 30M de entrada × R$ 0,59 = R$ 17,70 · 3M de saída × R$ 3,49 = R$ 10,47 → R$ 28,17.

3. Atendimento com RAG — R$ 0,0044 por pergunta

O padrão que mais gera valor: busca vetorial na sua base + resposta com as fontes. Entrada de ~4.000 tokens (pergunta + trechos recuperados), saída de ~400.

def responder(pergunta, buscar_trechos):
    trechos = buscar_trechos(pergunta, k=6)          # Qdrant, pgvector, o que voce usar
    contexto = "\n\n".join(f"[{i+1}] {t}" for i, t in enumerate(trechos))
    r = cliente.chat.completions.create(
        model="gpub-plus",
        messages=[
            {"role": "system", "content":
             "Responda usando SOMENTE o contexto. Cite as fontes como [1], [2]. "
             "Se a resposta nao estiver no contexto, diga que nao encontrou."},
            {"role": "user", "content": f"Contexto:\n{contexto}\n\nPergunta: {pergunta}"},
        ],
        temperature=0.2,
        max_tokens=500,
    )
    return r.choices[0].message.content, r.usage.cost_brl

Para o banco vetorial, o template Qdrant em 1 clique sobe em minutos e roda até sem GPU. Se preferir uma interface pronta de "ChatGPT da empresa", o AnythingLLM cobre o caminho inteiro.

Conta: 200M de entrada × R$ 0,69 = R$ 138,00 · 20M de saída × R$ 3,99 = R$ 79,80 → R$ 217,80.

4. Resumir reuniões — R$ 0,0065 por reunião

Uma hora de reunião transcrita dá algo em torno de 12.000 tokens. Como o gpub-fast tem 1 milhão de tokens de contexto, a transcrição inteira entra numa chamada só.

PROMPT = """Resuma a reuniao em:
1) Decisoes tomadas
2) Pendencias, com responsavel e prazo quando houver
3) Riscos mencionados
Seja factual. Nao invente responsavel nem prazo."""

def resumir(transcricao):
    r = cliente.chat.completions.create(
        model="gpub-fast",
        messages=[{"role": "system", "content": PROMPT},
                  {"role": "user", "content": transcricao}],
        max_tokens=800,
    )
    return r.choices[0].message.content, r.usage.cost_brl

Para gerar a transcrição, o Whisper Server em 1 clique roda numa GPU pequena e transcreve português muito bem — e áudio processa muito mais rápido que tempo real, então o custo de GPU também é baixo.

Conta: 12M de entrada × R$ 0,49 = R$ 5,88 · 0,6M de saída × R$ 1,09 = R$ 0,65 → R$ 6,53.

5 a 7. Catálogo, moderação e conteúdo — os que rodam em volume

5. Traduzir e localizar catálogo (20.000 descrições) — R$ 32,64

400 tokens de entrada, 400 de saída, no gpub-mini. Localizar não é só traduzir: peça adaptação de unidade, moeda e tom no mesmo prompt.

6. Moderar conteúdo (1 milhão de mensagens) — R$ 78,95

150 tokens de entrada, 5 de saída, no gpub-fast. Sai a R$ 0,000079 por mensagem. Use temperature=0 e uma política escrita no system prompt, e mande para revisão humana só o que ficar acima do limiar de dúvida.

7. Gerar descrição de produto (5.000 produtos) — R$ 6,02

300 tokens de entrada (ficha técnica), 250 de saída, no gpub-plus. Combine com geração de imagem em GPU por hora e o catálogo inteiro se renova por menos de R$ 50.

8. Agente que lê a base de código — e a lição de custo mais importante

Aqui aparece o efeito que pega todo mundo de surpresa: quem manda na conta é o contexto, não a resposta. Um agente que lê 200 mil tokens de repositório e escreve 5 mil de patch, 200 vezes no mês:

25× de diferença na mesma tarefa. Isso não quer dizer "use sempre o barato": quer dizer que vale medir. Rode os dois em 20 casos reais, compare a taxa de acerto e decida com número. Muitas vezes o modelo grande vence em 10% dos casos difíceis — e a arquitetura certa é usar o barato por padrão e escalar para o caro só quando o barato admitir dúvida.

def resolver(tarefa):
    r = cliente.chat.completions.create(
        model="gpub-plus",
        messages=[{"role": "system", "content":
                   "Se nao tiver certeza suficiente, responda exatamente: ESCALAR"},
                  {"role": "user", "content": tarefa}],
        max_tokens=1500,
    )
    saida = r.choices[0].message.content
    if "ESCALAR" in saida:                       # so o dificil paga caro
        r = cliente.chat.completions.create(
            model="gpub-max",
            messages=[{"role": "user", "content": tarefa}],
            max_tokens=4000,                     # modelo de raciocinio precisa de folga
        )
        saida = r.choices[0].message.content
    return saida

9 e 10. Contratos e CRM

9. Analisar contratos longos (500 contratos) — R$ 175,90

40 mil tokens de entrada, 2 mil de saída, no gpub-base. Peça cláusulas de risco, prazos, multas e renovação automática — sempre com a instrução de citar o trecho que sustenta cada apontamento. É o que transforma a saída em algo que o jurídico consegue conferir.

10. Qualificar leads no CRM (30.000 leads) — R$ 10,78

600 tokens de entrada (formulário + histórico), 60 de saída, no gpub-fast. Classificação de intenção, porte e urgência, gravada de volta no CRM. Casa muito bem com automação visual: o template n8n em 1 clique conecta formulário, API e CRM sem escrever serviço nenhum.

Quando parar de usar token e subir uma GPU

Existe um ponto em que a GPU dedicada fica mais barata que o token — e ele é calculável, não é opinião. Fizemos essa conta em detalhe, com os dois lados numerados, em Comparativo de preços de API de LLM em 2026. Adiantando o resumo: o volume precisa ser alto e constante; se a sua carga é em rajada, o token vence quase sempre.

Perguntas frequentes

Leia também: Comparativo de preços de API de LLM em 2026 · Como funciona a nossa API por token · Qdrant para RAG em 1 clique