InsightsArtigo · LLMOps

LLMOps: o que muda quando uma chamada a um modelo chega à produção

Prompts são lógica, avaliação é uma foto e nenhum provedor é para sempre. A disciplina operacional que uma chamada a um modelo precisa em produção.

Um prompt determina o comportamento e a qualidade de um sistema tão diretamente quanto o código, mas costuma ser tratado como um detalhe de implementação: uma string enfiada em algum lugar da aplicação, sem histórico do que mudou e por quê, sem um jeito fácil de reverter e sem como testar uma mudança de forma isolada antes que ela chegue à produção. Quando o sistema está no ar, essa lacuna deixa de ser cosmética.

Prompts são lógica, não strings

A solução básica é o controle de versão: os prompts ficam em arquivos próprios e são acompanhados como qualquer outra mudança. A versão mais madura desacopla por completo as mudanças de prompt dos deploys de código: mudar uma redação não deveria exigir um redeploy completo, sobretudo quando quem itera no prompt (um especialista do domínio, um product manager) não é quem cuida do pipeline de deploy.

O que precisa de versão é mais amplo que o texto: o modelo, os parâmetros (temperatura, máximo de tokens), os exemplos few-shot e a configuração de recuperação e de ferramentas que rodou junto com aquela chamada. O mesmo texto de prompt pode se comportar de forma diferente entre provedores, ou entre versões do mesmo modelo. Versionar só a string é versionar metade. E um histórico de versões sem avaliação associada só diz o que mudou, não se melhorou: cada mudança de prompt deveria rodar contra um conjunto de avaliação antes de ser integrada, com a mesma disciplina de rodar os testes antes de integrar código.

Avaliação é uma foto; monitoramento é um vídeo

Rodar uma suíte de avaliação uma vez, antes do lançamento, descreve a qualidade naquele momento e naquela amostra. Não diz nada sobre daqui a um mês, quando o tráfego incluir tipos de pergunta que o conjunto original nunca previu ou os documentos de base tiverem mudado. O monitoramento contínuo precisa de quatro coisas:

  • Uma estratégia de amostragem. Avaliar 100% do tráfego com um LLM como juiz não cabe no orçamento: é preciso amostrar continuamente, dando mais peso às mudanças recentes ou às respostas de baixa confiança.
  • Sinais online baratos que não precisam de juiz: polegar para cima ou para baixo, se o usuário reformulou a pergunta logo em seguida, se exportou a resposta.
  • Detecção de deriva. A fidelidade média desta semana se mantém? A distribuição das perguntas que chegam continua perto do que o conjunto de avaliação representa?
  • Limiares de alerta que transformem uma métrica numa ação: um rollback, um aviso ao plantão, não só um dashboard que ninguém olha.

O ciclo se fecha no conjunto de avaliação offline: cada falha real que o monitoramento detecta precisa entrar nele; caso contrário, o benchmark offline fica congelado no momento em que foi montado enquanto a produção continua andando.

Custo e latência por chamada, não por fatura

Uma requisição tradicional custa mais ou menos o mesmo, não importa o que o cliente pediu. O custo de uma chamada a um LLM varia enormemente de uma requisição para outra (tokens de entrada e saída, qual modelo, se rodou recuperação ou reranking), e sem medir isso por chamada, marcado por funcionalidade e por usuário, o único número disponível é a fatura total no fim do mês, que não responde nada sobre o que realmente sai caro.

A latência precisa da mesma granularidade: além das etapas do pipeline (embeddings, recuperação, reranking, geração), as respostas em streaming se dividem em tempo até o primeiro token e latência total, e a velocidade percebida acompanha mais o primeiro número do que o segundo. E quando um único pedido de um usuário dispara uma cadeia de chamadas a LLMs (um agente que chama uma ferramenta, avalia o resultado e chama de novo), o número que importa para a economia do produto é o custo total dessa cadeia, não o de cada chamada.

Nunca um único provedor

Fixar um único provedor no código é um ponto único de falha, o mesmo problema de qualquer outro sistema sem redundância. E a solução não é só o failover: é, desde o início, encaminhar cada tarefa ao modelo adequado conforme custo e complexidade, em vez de pagar por um modelo de ponta numa classificação simples. O fallback tem um problema de taxonomia: um rate limit ou um erro 5xx vale a pena tentar de novo em outro lugar; uma rejeição do filtro de conteúdo normalmente não, porque provavelmente vai ser recusada de novo pelo mesmo motivo e só soma latência.

Um circuit breaker (parar de chamar, por um tempo, um provedor que falha repetidamente, em vez de pagar o custo do fallback em cada requisição enquanto ele está fora) é o mesmo padrão usado no resto dos sistemas distribuídos. O que é realmente diferente de um failover de banco de dados: quando uma réplica assume o lugar de outra, os dados são idênticos. Quando uma chamada a um LLM passa para outro provedor, não há garantia de que a resposta seja equivalente (o formato, o tom ou a correção podem mudar), então uma resposta de fallback precisa da sua própria validação antes de chegar ao usuário; não basta que "a chamada à API não deu erro".

Guardrails agem antes de a resposta sair

Há uma diferença real entre medir a fidelidade numa amostra, depois do fato, e filtrar cada resposta, em tempo real, antes que ela chegue ao usuário. Um guardrail de produção roda uma verificação mais leve e rápida em cada resposta (o LLM juiz completo é caro demais para 100% do tráfego), bloqueia ou gera de novo quando ela falha, e reserva o juiz caro para a amostragem periódica.

Os dados sensíveis se movem em duas direções, e vale defender cada uma separadamente. Para dentro: um usuário que cola informação sensível num prompt que sai do sistema rumo a um provedor externo. Para fora, num sistema com vários clientes: a recuperação que devolve documentos privados de um cliente dentro da resposta a outro, um vazamento que o isolamento estrutural no banco de dados previne de forma muito mais confiável do que qualquer instrução no prompt.

E a injeção de prompt tem uma variante própria de RAG que é fácil deixar passar: instruções embutidas num documento recuperado, e não no que o usuário escreve. Se o sistema trata o conteúdo recuperado como algo a obedecer, e não como algo a citar, essa é a porta aberta. A defesa duradoura é de arquitetura: o conteúdo recuperado nunca tem autoridade para mudar o comportamento, só para ser citado. É a mesma disciplina que a verificação de citações já exige, e de quebra fecha também essa brecha.

O conteúdo recuperado nunca tem autoridade para mudar o comportamento, só para ser citado.

Implantar um prompt como se implanta código

Uma mudança de prompt ou de modelo tem o mesmo raio de impacto de um deploy de código, mas raramente é tratada com o mesmo rigor: uma mudança de redação muitas vezes chega a todos os usuários na requisição seguinte, porque "é só texto". O deploy canary aplica o mesmo mecanismo (encaminhar uma porcentagem pequena do tráfego, medir, ampliar) com uma diferença real: o sinal de que algo quebrou não é rápido nem binário como uma queda ou um pico de erros. É estatístico ("a fidelidade caiu de 94% para 89%") e precisa de volume e da mesma metodologia de avaliação rodando especificamente na fatia canary.

O deploy em sombra roda a versão nova ao lado da atual, numa cópia do tráfego real, sem mostrar a saída a ninguém: risco zero para os usuários, e fecha a distância entre um conjunto de avaliação sintético e o que as pessoas realmente perguntam, ao custo de dobrar o gasto com API enquanto durar. E o caminho de rollback só funciona se for rápido: apontar o tráfego de volta para a versão anterior do prompt precisa ser possível sem redeploy de código, que é justamente o motivo pelo qual o versionamento de prompts se desacopla do pipeline de deploy. O ideal é ligá-lo diretamente aos limiares de alerta do monitoramento, para que uma regressão se reverta sozinha em vez de esperar que alguém perceba.

Nada disso é exótico: é a mesma disciplina operacional que qualquer sistema em produção precisa, aplicada a um componente (uma chamada a um modelo) que falha, deriva e custa dinheiro de maneiras que um serviço típico não custa.

Compartilhe este insight

LinkedIn