Observabilidade para LLMs: monitoramento e avaliação com LangFuse

Fundamentos de Observabilidade em Aplicações de IA - Apresentação do Curso

Apresentando o curso e realizando a autodescrição

Olá! Eu sou Caroline, pessoa engenheira de Machine Learning (aprendizado de máquina) e IA, e vou conduzir o curso de Observabilidade para Aplicações de IA utilizando LangFuse.

Para fins de acessibilidade, faremos nossa autodescrição.

Audiodescrição: Caroline é uma pessoa branca, de olhos claros e cabelo loiro, usa óculos e veste uma camiseta preta com um detalhe branco. Ao fundo há uma parede lilás iluminada e uma estante com alguns objetos.

Introduzindo observabilidade para LLMs e a arquitetura do LangFuse

Neste curso, primeiro veremos os conceitos de observabilidade para LLMs (modelos de linguagem de grande porte). Existem particularidades em relação à observabilidade em sistemas tradicionais, devido ao fato de que aplicações com IA produzem resultados não determinísticos, o que já introduz alguns desafios.

Em seguida, entenderemos a arquitetura do LangFuse para organizar nosso código já orientado à observabilidade.

Também veremos como estruturar um trace (rastreamento): do que ele é composto, como o trace funciona no LangFuse e como se caracteriza um trace de uma aplicação de LLMs (modelos de linguagem de grande porte).

Iniciando a experimentação e a gestão de prompts

Nós passaremos à parte de experimentação e gestão de prompts (instruções).

Audiodescrição: A pessoa instrutora está em ambiente interno, em frente à câmera, com fundo neutro e iluminação uniforme, vestindo roupa casual e falando diretamente para a câmera.

Avançando para a avaliação da aplicação

Depois que concluirmos a gestão e a experimentação de prompts (instruções), nós também poderemos começar a avaliar nossa aplicação.

Nós veremos a parte de avaliação, incluindo os LLMs (modelos de linguagem de grande porte) atuais.

Concretizando a demo prática e ampliando o acesso ao monitoramento

Ao final do curso, nós teremos a demo (demonstração), porque não ficaremos apenas na parte teórica. Ao longo do curso, nós também desenvolveremos a parte prática por meio de uma demo (demonstração) que evoluirá aula a aula, para que, ao final, possamos simular um monitoramento usando nosso código como se fosse uma aplicação em produção e obter um resultado no qual possamos entender cada parte de uma pipeline (fluxo de processamento) de observabilidade para aplicações com IA e manter isso em nosso código organizado de forma que possamos versioná-lo, dar manutenção e também acompanhá-lo na UI (interface do usuário) do LangFuse.

Assim, não apenas pessoas desenvolvedoras, mas também pessoas mais próximas do produto e do negócio poderão ter um contato mínimo com o que está ocorrendo em uma aplicação em um ambiente produtivo de IA.

E isso é tudo. Até a próxima!

Fundamentos de Observabilidade em Aplicações de IA - Entendendo Desafios de Observabilidade para LLMs

Apresentando o cenário de inconsistências

Antes de falar de ferramentas, vamos apresentar um cenário. Vamos imaginar que colocamos um chatbot (assistente de conversa) em produção. Uma pessoa cliente já está utilizando esse chatbot (assistente de conversa) e começa a reclamar de muitas respostas inconsistentes. Então, decidimos investigar o que está acontecendo e reproduzir esse comportamento para entender onde está o problema.

Contudo, não temos visibilidade de qual é o contexto em que a resposta está sendo incoerente dentro desse pipeline (fluxo de processamento) de LLM (Modelo de Linguagem de Grande Porte); não temos visibilidade do prompt (instrução) que está sendo utilizado. Temos visibilidade do modelo, mas não temos visibilidade da quantidade de tokens (unidades de texto) que estão sendo enviados ao modelo, da quantidade de tokens (unidades de texto) que estão retornando e de quanto isso está custando.

Assim, começamos a realizar o deploy (implantação) de uma aplicação em um ambiente de produção que não apresenta confiabilidade nem um custo previsível. Esse é o cenário real de muitas aplicações que hoje estão em produção com LLMs (Modelos de Linguagem de Grande Porte). Precisamos observar esse aspecto; é nesse ponto que entra a observabilidade.

Comparando observabilidade tradicional e para LLMs

Existe uma diferença importante entre a observabilidade para LLMs (Modelos de Linguagem de Grande Porte) e a observabilidade tradicional. Hoje, em uma aplicação sem LLMs (Modelos de Linguagem de Grande Porte), normalmente observamos algumas métricas simples por meio de logs (registros) e alguns traces (rastreamentos), caso já tenhamos instrumentado essa aplicação em alguma ferramenta.

Esses logs (registros) costumam incluir a medição de latência e a avaliação do desempenho do sistema para verificar se as respostas estão de acordo com o que nós, como pessoas usuárias do sistema, esperamos. Podemos fazer isso porque temos uma resposta definida: qual é a resposta correta e o que esperamos que o sistema envie. Podemos comparar essa saída com a resposta definida, que esperamos que o sistema devolva no formato correto.

Por outro lado, quando o sistema inclui LLMs (Modelos de Linguagem de Grande Porte), não temos esse comportamento de forma determinística. Começando pelas respostas: elas não são determinísticas. As razões para isso incluem o prompt (instrução); dependendo de como o prompt (instrução) está escrito, ele pode alterar a resposta final. Também depende do modelo que estivermos utilizando; cada modelo é avaliado de forma distinta. Aqui encontramos nossos primeiros desafios.

Apresentando o LangFuse e próximos passos

Assim, começamos a analisar a observabilidade de LLMs (Modelos de Linguagem de Grande Porte), e a ferramenta LangFuse é essencial para isso. Ela vai nos ajudar com toda a instrumentação de nossos pipelines (fluxos de processamento) e aplicações de LLMs (Modelos de Linguagem de Grande Porte), para proporcionar visibilidade das métricas e trazer confiabilidade ao sistema em produção.

Nas próximas aulas, nós vamos falar um pouco sobre a arquitetura e os componentes presentes em LangFuse, para que, nas próximas, demos continuidade: teremos nossas primeiras interações com a UI (Interface do Usuário) do LangFuse e também iniciaremos o desenvolvimento de nossa demonstração.

Tudo pronto. Até a próxima! [♪]

Fundamentos de Observabilidade em Aplicações de IA - Arquitetura e conceitos do Langfuse

Apresentando o LangFuse e seus componentes

Agora que introduzimos o problema, vamos começar a discutir a solução. Primeiro, vamos ao básico. O que é LangFuse? LangFuse é uma plataforma de observabilidade para aplicações de LLM (modelos de linguagem de grande porte — Large Language Models). Essa plataforma pretende resolver todos os problemas que vimos no vídeo anterior.

Como faz isso? Vamos entender os componentes principais da arquitetura do LangFuse. Esses componentes são um SDK (kit de desenvolvimento de software), uma API (interface de programação de aplicações), um sistema de armazenamento e a UI (interface do usuário) do LangFuse. Como se conectam e como funcionam em segundo plano junto com nossa aplicação?

Nossa aplicação envia e recebe dados. Quando usamos o LangFuse, o SDK integrado à aplicação captura esses dados e os envia para a API. A API armazena os dados no sistema de armazenamento, e a UI consome esses dados a partir do banco de dados para exibi-los no painel de controle, permitindo visualizar todos os dados, todos os logs (registros), todos os traces (rastreamentos) e todas as métricas que estamos instrumentando em nossa aplicação. Esses são os componentes principais da arquitetura.

Detalhando a arquitetura com foco em latência

Há um detalhe importante na arquitetura do LangFuse voltado a fluxos em produção que exigem latência muito baixa, principalmente fluxos de atendimento direto à pessoa cliente. Existe uma funcionalidade em segundo plano: quando estamos enviando os dados, isto é, quando o SDK envia os dados para a API, esse processo não bloqueia nossa aplicação; é executado de forma assíncrona, em paralelo. Isso evita adicionar uma camada extra de latência na aplicação.

Utilizar o LangFuse não elimina a latência, mas a plataforma busca minimizar a sobrecarga e evitar adicionar mais latência à aplicação. Sabemos que, às vezes, um prompt (instrução) muito grande ou uma chamada ao modelo pode gerar latência maior, e precisamos otimizar todos os pontos possíveis, principalmente em chatbots (robôs de conversa) e aplicações conversacionais.

A arquitetura do LangFuse já foi concebida e otimizada para esse cenário.

Explicando os conceitos de Trace, Span, Event e Generation

Agora que entendemos os componentes da arquitetura do LangFuse, vamos compreender como funciona, pois isso é essencial para pensarmos na instrumentação da nossa aplicação e em como organizá-la para visualizar tudo de forma clara e simples na UI (interface do usuário).

Os quatro componentes principais do LangFuse são Trace, Span, Event e Generation. O que é cada um deles?

Primeiro, o Trace. Ele representa o fluxo completo da aplicação. Ao executarmos a aplicação, é gerado um Trace. Independentemente do que estiver acontecendo, esse Trace registra que a aplicação foi executada. Temos uma arquitetura hierárquica desses componentes.

Dentro desse Trace principal da aplicação, podemos ter Spans. O que são Spans? Eles representam uma execução dentro desse fluxo, isto é, dentro do pipeline (fluxo de processamento) da aplicação. Ao instrumentarmos algo como Span, estamos registrando uma execução que ocorreu na aplicação, com início e fim, e, portanto, com duração.

Em relação ao Event, ele é semelhante ao Span, mas não é a mesma coisa. Em um Event, não registramos uma execução, pois uma execução tem início e fim, tem uma duração. O Event é utilizado para fatos que ocorrem pontualmente no modelo e não têm duração, não têm início nem fim. Pode ser, por exemplo, um registro de que recebemos uma determinada entrada (input) ou um registro de fallback (retorno alternativo) — o modelo entrou em fallback. Isso não consome tempo dessa execução; apenas deixa o registro no histórico do Trace para que possamos entender melhor, por meio de observabilidade, cada passo da aplicação.

Por fim, temos o Generation. O que é o Generation? É a chamada ao modelo. No momento em que fazemos a chamada ao modelo, ela não é registrada como um Span, não é registrada como um novo Trace e não é registrada como um Event. É registrada como Generation.

Pensando na hierarquia: ao executar a aplicação, temos um Trace e, dependendo do que instrumentarmos, dentro do Trace poderemos ter Spans, Events e Generations.

Antecipando a próxima aula e encerrando

Na próxima aula, teremos nosso primeiro contato com a UI (interface do usuário) do LangFuse. Vamos mostrar, passo a passo, como realizar essa configuração inicial e o primeiro acesso, e vamos instrumentar uma aplicação simples para iniciar, de fato, a parte mais prática do curso.

Agradecemos e até a próxima aula.

Sobre o curso Observabilidade para LLMs: monitoramento e avaliação com LangFuse

O curso Observabilidade para LLMs: monitoramento e avaliação com LangFuse possui 274 minutos de vídeos, em um total de 56 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Fundamentos de Observabilidade em Aplicações de IA
• Tracing e instrumentação de pipelines de IA
• Gerenciamento e experimentação de prompts
• Avaliação de Sistemas com LLMs
• Monitoramento e operação em produção