Como Monitorar LLMs em Java e Prometheus

A inteligência artificial generativa conquistou o desenvolvimento de software corporativo. No entanto, muitas equipes de TI enfrentam uma surpresa desagradável quando o primeiro boleto da OpenAI ou Anthropic chega. Uma única consulta mal formulada ou um loop infinito de agentes inteligentes pode consumir milhares de tokens redundantes em poucos minutos. Para desenvolvedores Java acostumados com APIs REST tradicionais, essa falta de previsibilidade representa um desafio financeiro e técnico inédito.

Felizmente, monitorar essas aplicações em tempo real é a melhor solução para evitar desperdícios. Integrando Java, Prometheus e Spring Boot, você ganha controle total sobre as métricas de seus modelos de linguagem. Neste guia de observabilidade, mostraremos como capturar o consumo de tokens e a latência de requisições passo a passo.

O Custo Invisível dos Agentes de IA em Produção

Empresas que adotam inteligência artificial generativa enfrentam uma dura realidade financeira logo nos primeiros meses. Afinal, as chamadas para LLMs em produção não funcionam como microsserviços comuns. Um único loop de feedback em um agente autônomo pode gerar requisições massivas em cascata, estourando o orçamento planejado para o projeto rapidamente.

De acordo com um estudo recente da Datadog sobre o estado da observabilidade, a latência de chamadas para LLMs é até dez vezes maior do que serviços de banco de dados tradicionais. Portanto, monitorar o consumo de tokens e o tempo de resposta torna-se uma prioridade máxima de infraestrutura. Sem métricas claras, sua equipe fica cega diante de falhas de conectividade, formatações incorretas ou loops descontrolados.

Além disso, a integração com agentes cognitivos complexos exige atenção redobrada. Ao utilizar ferramentas como as sugeridas em LangChain4j e Virtual Threads: Agentes de IA em Java, a execução concorrente de tarefas pode camuflar gargalos de rede. Dessa forma, você precisa de dados centralizados para entender a saúde real do seu ecossistema de software.

Por que a Observabilidade de LLMs é Diferente de APIs Tradicionais?

APIs REST tradicionais respondem com códigos de status HTTP bem conhecidos, como 200, 400 ou 500. No entanto, uma API de modelo de linguagem pode retornar um status HTTP 200 e, ainda assim, entregar uma resposta totalmente vazia ou desconexa. Por isso, as métricas clássicas de saúde de microsserviços não conseguem medir a real qualidade desses sistemas.

Precisamos acompanhar três pilares específicos para sistemas inteligentes. Primeiro, monitoramos o volume de tokens, segmentando entre tokens de entrada e tokens de saída. Segundo, avaliamos a latência total da chamada e o tempo até o primeiro token em conexões de streaming. Terceiro, rastreamos a taxa de erros semânticos e falhas de integração com ferramentas externas.

Para resolver essa deficiência no ecossistema Java, utilizamos a biblioteca Micrometer. Ela é o padrão de mercado no ecossistema do Spring Boot para exportação de dados de desempenho. Assim, conseguimos converter informações complexas de uso de IA em métricas compreensíveis para o Prometheus.

Configurando o Ambiente Java com LangChain4j e Micrometer

Primeiramente, configuramos as dependências essenciais de nosso projeto Java utilizando o ecossistema do Spring Boot. Utilizaremos o LangChain4j, que permite integrar com OpenAI e Claude de forma padronizada. Portanto, certifique-se de adicionar as dependências corretas em seu arquivo de automação de build do Maven.

Além disso, o suporte ao Prometheus Actuator precisa ser declarado explicitamente. Veja abaixo a configuração das dependências necessárias para o arquivo pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>0.32.0</version>
</dependency>

Em seguida, precisamos expor o endpoint de coleta do Prometheus nas configurações globais da aplicação. No arquivo application.properties, ative os caminhos necessários para permitir a raspagem de métricas pelo coletor externo:

management.endpoints.web.exposure.include=prometheus,health,info
management.metrics.tags.application=ia-copilot-servico

Implementando o Monitoramento de Consumo de Tokens no Java

Depois de configurar o projeto, precisamos criar os interceptadores para capturar cada chamada enviada ao modelo de linguagem. O framework LangChain4j conta com ouvintes nativos que tornam essa interceptação extremamente simples. Dessa forma, registramos o consumo exato de tokens sem misturar lógica de monitoramento com as regras de negócio.

Por exemplo, criamos uma classe de configuração Java para registrar métricas diretamente no Micrometer MeterRegistry. O código abaixo demonstra como inicializar e atualizar contadores personalizados de forma assíncrona e segura:

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Counter;
import dev.langchain4j.model.chat.listener.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ObservabilidadeIaConfig {

    @Bean
    public ChatModelListener chatModelListener(MeterRegistry registry) {
        Counter promptTokens = Counter.builder("llm.tokens.prompt")
            .description("Quantidade de tokens enviados")
            .register(registry);

        Counter completionTokens = Counter.builder("llm.tokens.completion")
            .description("Quantidade de tokens gerados")
            .register(registry);

        return new ChatModelListener() {
            @Override
            public void onRequest(ChatModelRequestContext context) {
                // Registro inicial de chamada se necessario
            }

            @Override
            public void onResponse(ChatModelResponseContext context) {
                if (context.response() != null && context.response().tokenUsage() != null) {
                    promptTokens.increment(context.response().tokenUsage().inputTokenCount());
                    completionTokens.increment(context.response().tokenUsage().outputTokenCount());
                }
            }

            @Override
            public void onError(ChatModelErrorContext context) {
                registry.counter("llm.errors", "type", context.error().getClass().getSimpleName()).increment();
            }
        };
    }
}

Além disso, você pode estender essa estrutura para auditar consultas sensíveis de banco de dados orientadas por IA. Se você trabalha com o modelo descrito em LGPD e IA na Otimização de SQL com LLM em Produção, esse nível de auditoria garante a conformidade com as regras de governança e segurança vigentes.

Integrando as Métricas do Java ao Servidor Prometheus

Após a exposição das métricas no endereço de rede /actuator/prometheus, configuramos o servidor do Prometheus para coletar os dados. Esse processo de coleta é realizado por meio de uma tarefa simples de varredura (scrape) configurada no servidor central.

No arquivo de configuração prometheus.yml, adicione a definição do serviço para capturar dados do microsserviço Java periodicamente:

scrape_configs:
  - job_name: 'ia-springboot-app'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:8080']

Posteriormente, esses dados brutos podem ser visualizados de forma profissional no Grafana. Assim, sua equipe consegue criar alertas automatizados para identificar aumentos repentinos na latência ou picos anômalos no consumo diário de tokens.

Perguntas frequentes

Como posso reduzir o custo de tokens em produção?

Você pode mitigar o consumo excessivo de tokens aplicando cache para prompts repetitivos do sistema. Além disso, reduzir o histórico armazenado em conversas longas e empregar modelos menores para tarefas simples de classificação otimiza bastante o orçamento.

O Prometheus consegue capturar dados de latência de streaming?

Sim, o Prometheus consegue captar essas informações de latência utilizando as classes de temporizadores (Timer) do Micrometer. Com essa configuração, você registra o momento exato do recebimento do primeiro caractere gerado pelo modelo e a duração total da resposta.

Posso integrar essa solução com agentes baseados em LangChain do Python?

Esta arquitetura foca na integração do ecossistema corporativo do Java com a biblioteca LangChain4j. No entanto, o Prometheus opera de forma agnóstica a linguagens de programação, exigindo apenas bibliotecas compatíveis com Micrometer para expor as métricas em Python.

Conclusão

Gerenciar sistemas de inteligência artificial em ambientes produtivos sem ferramentas de monitoramento expõe as empresas a sérios riscos técnicos e financeiros. Neste artigo, você aprendeu como capturar dados sobre o uso de tokens e latência com ferramentas consagradas de mercado. Essa estrutura protege sua aplicação contra custos indesejados e garante a eficiência técnica que seus clientes esperam.

Para aprender novas técnicas de integração e continuar evoluindo em sua carreira de desenvolvimento, confira outros guias práticos em nosso portal Nerd. Acesse agora mesmo nosso tutorial sobre Testes de LLM em CI/CD com LangChain4j e Java e otimize seus pipelines de automação hoje mesmo!

Por que a Observabilidade de LLMs com Prometheus é Diferente?

Monitorar aplicações tradicionais envolve analisar latência de banco de dados e uso de CPU. No entanto, quando inserimos modelos de linguagem em produção, o cenário muda completamente.

Primeiramente, as requisições para APIs de inteligência artificial são imprevisíveis. Por exemplo, uma resposta pode demorar milissegundos ou minutos dependendo do tamanho do prompt enviado pelo usuário. Portanto, apenas medir o tempo de resposta geral não ajuda a identificar gargalos reais no sistema.

Além disso, o consumo financeiro está diretamente atrelado ao volume de dados processados. Como cada chamada consome tokens de entrada e saída, um pico de uso inadequado pode estourar seu orçamento rapidamente. Por isso, integrar métricas personalizadas com Spring Boot e Prometheus é a escolha mais inteligente para times de alta performance.

As Quatro Métricas Críticas para Monitorar em seu Projeto Java

Para garantir a saúde do seu sistema, você precisa coletar dados específicos da interação com a IA. Dessa forma, conseguimos tomar decisões baseadas em fatos reais sobre a infraestrutura.

Abaixo, listamos os quatro indicadores indispensáveis que você deve configurar no Micrometer do seu projeto Spring Boot:

Configurando o Spring Boot para Expor Métricas do Prometheus

Felizmente, o ecossistema Java facilita muito esse trabalho de instrumentação. Nós utilizaremos o Spring Boot Actuator junto com a biblioteca Micrometer Prometheus.

Primeiro, adicione as dependências necessárias no arquivo pom.xml do seu projeto Maven. Veja o exemplo de configuração:

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
 <groupId>io.micrometer</groupId>
 <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Em seguida, habilite o endpoint do Prometheus no arquivo application.properties da sua aplicação. Isso permite que o coletor de dados consiga ler as informações:

management.endpoints.web.exposure.include=prometheus,health
management.metrics.tags.application=meu-app-llm

Depois disso, basta criar um componente Java para registrar as métricas customizadas sempre que uma chamada ao modelo for realizada. Consequentemente, o Prometheus começará a coletar esses valores automaticamente no endpoint padrão do Actuator.

Instrumentando Chamadas de LLM na Prática com Java

Vamos agora construir um exemplo prático de serviço Java que faz a contagem de tokens utilizando o Micrometer. Esse padrão ajuda a garantir a máxima precisão nos seus relatórios de consumo.

Veja como criar uma classe de serviço estruturada para registrar essas informações vitais:

@Service
public class LlmMonitorService {

 private final MeterRegistry registry;
 private final Counter tokenCounter;

 public LlmMonitorService(MeterRegistry registry) {
 this.registry = registry;
 this.tokenCounter = Counter.builder("llm_tokens_total")
 .description("Contagem de tokens utilizados")
 .tags("tipo", "prompt")
 .register(registry);
 }

 public void registrarConsumo(int quantidadeTokens) {
 this.tokenCounter.increment(quantidadeTokens);
 }
}

Dessa maneira, você consegue rastrear o consumo em tempo real. Além disso, recomendamos integrar esse serviço com bibliotecas modernas de IA no mundo Java, como o LangChain4j.

Se você quer saber mais sobre como testar essas integrações com segurança antes de enviar para produção, leia também nosso artigo sobre Práticas Modernas de Testes com Java para construir softwares extremamente robustos.

Criando Alertas Inteligentes no Prometheus para Evitar Prejuízos

Coletar dados é importante, mas agir rápido diante de anomalias é o que realmente salva sua operação. Por essa razão, configurar regras de alerta no Prometheus é um passo indispensável para qualquer equipe de engenharia.

Para isso, nós escrevemos regras específicas baseadas no comportamento esperado da sua aplicação. Se a taxa de erros de requisição de IA passar de 5% em um intervalo de 5 minutos, sua equipe de plantão deve ser notificada imediatamente via Slack ou Discord.

Além disso, de acordo com as boas práticas de engenharia de confiabilidade do Google, descritas em seu SRE Book oficial, o monitoramento deve sempre focar nos quatro sinais dourados: latência, tráfego, erros e saturação. Portanto, ao integrar Prometheus e Grafana, você cria uma visão holística e em tempo real sobre toda a sua infraestrutura de inteligência artificial.

Perguntas frequentes

O Prometheus consegue monitorar chamadas de LLM de forma assíncrona em Java?

Sim, ele monitora perfeitamente. O Micrometer trabalha de forma assíncrona ao registrar as métricas na memória da JVM, garantindo que o processo de raspagem de dados pelo Prometheus não afete o desempenho das suas requisições de IA.

Como faço para medir a latência exata do token gerado pela IA?

Para obter essa precisão, você deve medir a métrica de tempo até o primeiro token (Time to First Token) usando streams em Java. Registre esse valor em um Histogram do Micrometer para acompanhar a experiência do usuário em tempo real.

Preciso usar o Spring Boot Actuator para o Prometheus funcionar com Java?

Não necessariamente, contudo o Actuator facilita drasticamente o trabalho. Sem ele, você precisará configurar manualmente um servidor HTTP simples no Java para expor as métricas no formato do Prometheus, o que aumenta a complexidade do código desnecessariamente.

Conclusão

Em resumo, garantir a observabilidade de aplicações de inteligência artificial em produção é um requisito obrigatório para o sucesso do seu negócio. Ao integrar Java, Spring Boot e Prometheus, você assume o controle total sobre o consumo de tokens, custos e latência do sistema.

Quer levar o monitoramento da sua infraestrutura para o próximo nível hoje mesmo? Fale com nosso time de engenheiros de confiabilidade, agende uma demonstração gratuita das nossas soluções de monitoramento e garanta a estabilidade que seus clientes merecem!

Leia também

• AWS WAF e Spring Boot: Blindando APIs contra OWASP Top 10
• LangChain4j e Virtual Threads: Agentes de IA em Java
• Testes de LLM em CI/CD com LangChain4j e Java