Fluxo de trabalho do desenvolvedor do aplicativo de IA generativo

O desenvolvimento de um aplicativo de IA generativa robusto (aplicativo de IA gen) requer um planejamento deliberado, um ciclo rápido de desenvolvimento, feedback e avaliação, e uma infraestrutura de produção escalonável. Esse fluxo de trabalho descreve uma sequência recomendada de etapas para guiá-lo da POC (prova de conceito) inicial para a implantação de produção.

0. Pré-requisitos

• Reunir requisitos para validar a adequação da IA de geração e identificar restrições.
• Crie sua arquitetura de solução. Ver padrões de design do sistema do Agente

1. Compilar

• Prepare fontes de dados e crie as ferramentas necessárias.
• Compilar e validar o protótipo inicial (POC).
• Implantar no ambiente de pré-produção.

2. Avaliar e Iterar

• Coletar comentários do usuário e medir a qualidade
• Corrija problemas de qualidade refinando a lógica do agente e as ferramentas com base na avaliação.
• Incorporar a entrada do especialista no assunto (SME) para melhorar continuamente a qualidade do sistema de agentes.

3. Produção

• Implantar o aplicativo de IA generativa no ambiente de produção.
• Monitore o desempenho e a qualidade.
• Mantenha e melhore com base no uso do mundo real.

Esse fluxo de trabalho deve ser iterativo: após cada ciclo de implantação ou avaliação, retorne às etapas anteriores para refinar pipelines de dados ou atualizar a lógica do agente. Por exemplo, o monitoramento da produção pode revelar novos requisitos, levando a atualizações no design do agente e a mais uma rodada de avaliação. Seguindo essas etapas sistematicamente e aproveitando o rastreamento do MLflow do Databricks, o Framework de Agente e a Avaliação de Agente, você pode criar aplicativos de IA de alta qualidade que atendam de forma confiável às necessidades do usuário, respeitem os requisitos de segurança e conformidade e continuem a se aprimorar ao longo do tempo.

0. Pré-requisitos

Antes de começar a desenvolver seu aplicativo de IA generativa, não se pode exagerar a importância de dedicar tempo para fazer o seguinte corretamente: coleta de requisitos e design de solução.

A coleta de requisitos inclui as seguintes etapas:

• Valide se a IA de geração se ajusta ao seu caso de uso.
• Defina a experiência do usuário.
• Avalie as fontes de dados.
• Definir restrições de desempenho.
• Capturar restrições de segurança.

O design da solução inclui o seguinte:

• Mapear pipelines de dados.
• Identifique as ferramentas necessárias.
• Descrever a arquitetura geral do sistema.

Ao definir essa base, você define uma direção clara para os estágios de build, avaliação e produção subsequentes.

Reunir requisitos

Definir requisitos de caso de uso claros e abrangentes é uma primeira etapa crítica no desenvolvimento de seu aplicativo de IA de geração bem-sucedido. Esses requisitos atendem às seguintes finalidades:

• Eles ajudam a determinar se uma abordagem de IA de geração é apropriada para seu caso de uso.
• Eles orientam as decisões de design, implementação e avaliação da solução.

Investir tempo no início para reunir requisitos detalhados pode evitar desafios significativos posteriormente no processo de desenvolvimento e garantir que a solução resultante atenda às necessidades dos usuários finais e dos stakeholders. Os requisitos bem definidos fornecem a base para os estágios subsequentes do ciclo de vida do aplicativo.

O caso de uso é uma boa opção para IA generativa?

Antes de se comprometer com uma solução de IA de geração, considere se seus pontos fortes inerentes estão alinhados com seus requisitos. Alguns exemplos em que uma solução de IA gerativa é uma boa opção incluem:

• Geração de conteúdo: A tarefa requer a geração de conteúdo novo ou criativo que não pode ser obtido com modelos estáticos ou lógica simples baseada em regras.
• Tratamento dinâmico de consulta: As consultas de usuário são abertas ou complexas e exigem respostas flexíveis e com reconhecimento de contexto.
• Síntese de informações: O caso de uso se beneficia de combinar ou resumir diversas fontes de informação para produzir uma saída coerente.
• Sistemas de agente: O aplicativo requer mais do que apenas gerar texto em resposta a um prompt. Talvez seja necessário que ele seja capaz de:
  • Planejamento e tomada de decisões: Formular uma estratégia de várias etapas para atingir uma meta específica.
  • Realizando ações: Disparar processos externos ou chamar várias ferramentas para executar tarefas (por exemplo, recuperar dados, fazer chamadas à API, executar consultas SQL, executar código).
  • Mantendo o estado: Manter o controle do histórico de conversas ou do contexto da tarefa em várias interações para habilitar a continuidade.
  • Produzindo saídas adaptáveis: Gerando respostas que evoluem com base em ações anteriores, informações atualizadas ou condições de alteração.

Por outro lado, uma abordagem de IA de geração pode não ser ideal nas seguintes situações:

• A tarefa é altamente determinística e pode ser efetivamente resolvida com modelos predefinidos ou sistemas baseados em regras.
• Todo o conjunto de informações necessárias já está estático ou se encaixa em uma estrutura simples e fechada.
• Respostas de latência extremamente baixa (milissegundos) são necessárias e a sobrecarga do processamento generativo não pode ser acomodada.
• Respostas simples e com modelo são suficientes para o caso de uso pretendido.

Importante

As seções abaixo usam rótulos P0, P1 e P2 para indicar prioridade relativa.

•  [P0] os itens são críticos ou essenciais. Elas devem ser tratadas imediatamente.
•  [P1] itens são importantes, mas podem ser concluídos após os requisitos P0.
• ⚪ [P2] itens são considerações de prioridade mais baixa ou aprimoramentos que podem ser resolvidos se houver tempo e recursos disponíveis.

Esses rótulos ajudam as equipes a ver rapidamente quais requisitos precisam de atenção imediata versus quais podem ser adiados.

Experiência do usuário

Defina como os usuários interagirão com o aplicativo de IA de geração e que tipo de respostas são esperadas.

•  [P0] Solicitação típica: como será uma solicitação de usuário típica? Reúna exemplos de partes interessadas.
•  [P0] Respostas esperadas: Que tipo de respostas o sistema deve gerar (por exemplo, respostas curtas, explicações de forma longa, narrativas criativas)?
•  [P1] Modalidade de interação: como os usuários interagirão com o aplicativo (por exemplo, interface de chat, barra de pesquisa, assistente de voz)?
•  [P1] Tom, estilo, estrutura: qual tom, estilo e estrutura os resultados gerados devem adotar (formal, conversacional, técnica, listas com marcadores ou prosa contínua)?
•  [P1]Tratamento de erros: como o aplicativo deve lidar com consultas ambíguas, incompletas ou fora do destino? Ele deve fornecer comentários ou solicitar esclarecimentos?
• ⚪ [P2] Requisitos de formatação: Há alguma formatação específica ou diretrizes de apresentação para as saídas (incluindo metadados ou informações complementares)?

Dados

Determine a natureza, as fontes e a qualidade dos dados que serão usados no aplicativo de IA de geração.

• [P0] Fontes de dados: Quais fontes de dados estão disponíveis?
  • Para cada origem, determine:
    • Os dados são estruturados ou não estruturados?
    • Qual é o formato de origem (por exemplo, PDF, HTML, JSON, XML)?
    • Onde os dados residem?
    • Quantos dados estão disponíveis?
    • Como os dados devem ser acessados?
• [P1] Atualizações de dados: Com que frequência os dados são atualizados? Quais mecanismos estão em vigor para lidar com atualizações?
• [P1] Qualidade dos dados: Há problemas de qualidade conhecidos ou inconsistências?
  • Considere se algum monitoramento de qualidade em fontes de dados será necessário.

Considere a criação de uma tabela de inventário para consolidar essas informações, por exemplo:

Fonte de dados	Fonte	Tipos de arquivo	Tamanho	Frequência de atualização
Fonte de dados 1	Volume do Catálogo Unity	JSON	10 GB	Diariamente
Fonte de dados 2	API pública	XML	N/D (API)	Tempo real
Fonte de dados 3	SharePoint	PDF, .docx	500 MB	Mensalmente

Restrições de desempenho

Capture os requisitos de desempenho e de recursos para o aplicativo de IA de geração.

Latência

• [P0] Tempo até o primeiro token: Qual é o atraso máximo aceitável antes de entregar o primeiro token de resultado?
  • Nota: A latência normalmente é medida usando p50 (mediana) e p95 (percentil 95) para capturar o desempenho médio e o pior.
• [P0] Tempo de conclusão: Qual é o tempo de resposta aceitável (tempo de conclusão) para os usuários?
• [P0] Latência de streaming: Se as respostas forem transmitidas, uma latência geral maior será aceitável?

Escalabilidade

• [P1]Usuários simultâneos e solicitações: quantos usuários ou solicitações simultâneas o sistema deve suportar?
  • Observação: a escalabilidade geralmente é medida em termos de QPS (consultas por segundo) ou QPM (consultas por minuto).
• [P1] Padrões de uso: Quais são os padrões de tráfego esperados, cargas de pico ou picos baseados em tempo no uso?

Restrições de custo

• [P0] Limitações de custo de inferência: Quais são as restrições de custo ou as limitações de orçamento para recursos de computação de inferência?

Avaliação

Estabeleça como o aplicativo de IA de geração será avaliado e aprimorado ao longo do tempo.

• [P0] KPIs de negócios: Qual meta de negócios ou KPI o aplicativo deve afetar? Defina seus valores de linha de base e metas.
• [P0] Comentários das partes interessadas: Quem fornecerá comentários iniciais e contínuos sobre o desempenho e as saídas do aplicativo? Identifique grupos de usuários específicos ou especialistas em domínio.
• [P0] Medindo a qualidade: Quais métricas (por exemplo, precisão, relevância, segurança, pontuações humanas) serão usadas para avaliar a qualidade das saídas geradas?
  • Como essas métricas serão computadas durante o desenvolvimento (por exemplo, em relação a dados sintéticos, conjuntos de dados coletados manualmente)?
  • Como a qualidade será medida na produção (por exemplo, registrando e analisando respostas a consultas reais do usuário)?
  • Qual é a tolerância geral ao erro? (por exemplo, aceite um determinado percentual de pequenas imprecisões factuais ou requeira quase 100% de correção para casos críticos de uso.)
  • O objetivo é desenvolver um conjunto de avaliação baseado em consultas de usuários reais, dados sintéticos ou uma combinação de ambos. Esse conjunto fornece uma maneira consistente de avaliar o desempenho à medida que o sistema evolui.
• [P1] Ciclos de feedback: como o feedback do usuário deve ser coletado (por exemplo, positivos/negativos, formulários de pesquisa) e usado para impulsionar melhorias iterativas?
  • Planeje com que frequência os comentários serão revisados e incorporados.

Segurança

Identifique quaisquer considerações de segurança e privacidade.

•  [P0] Confidencialidade de dados: há elementos de dados confidenciais ou confidenciais que exigem tratamento especial?
•  [P1] Controles de acesso: você precisa implementar controles de acesso para restringir determinados dados ou funcionalidades?
• [P1] Avaliação e mitigação de ameaças: Seu aplicativo precisará se proteger contra ameaças comuns de IA generativa, como injeção de comando ou entradas de usuários maliciosos?

Implantação

Entenda como a solução de IA de geração será integrada, implantada, monitorada e mantida.

• [P1] Integração: Como a solução de IA de geração deve se integrar aos sistemas e fluxos de trabalho existentes?
  • Identificar pontos de integração (por exemplo, Slack, CRM, ferramentas de BI) e conectores de dados necessários.
  • Determine como as solicitações e respostas fluirão entre o aplicativo de IA de geração e os sistemas downstream (por exemplo, APIs REST, webhooks).
• [P1] Implantação: Quais são os requisitos para implantar, dimensionar e fazer o controle de versão do aplicativo? Este artigo aborda como o ciclo de vida de ponta a ponta pode ser tratado no Databricks usando MLflow, Catálogo do Unity, Estrutura do Agente, Avaliação de Agente e Serviço de Modelo.
• [P1] Monitoramento de produção e observabilidade: Como você monitorará o aplicativo quando ele estiver em produção?
  • Registro em log e rastreamentos: capture rastreamentos de execução completos.
  • Métricas de qualidade: avalie continuamente as principais métricas (como correção, latência, relevância) no tráfego ao vivo.
  • Alertas e painéis de controle: defina alertas para questões críticas.
  • Loop de comentários: incorpore os comentários de usuários na produção (polegares para cima e para baixo) para identificar os problemas logo no início e promover melhorias iterativas.

Exemplo

Por exemplo, considere como essas considerações e requisitos se aplicam a um aplicativo RAG agente hipotético usado por uma equipe de suporte ao cliente do Databricks:

Área	Considerações	Requisitos
Experiência do usuário	Modalidade de interação. Exemplos típicos de consulta de usuário. Formato e estilo de resposta esperados. Tratamento de consultas ambíguas ou irrelevantes.	Interface de chat integrada ao Slack. Exemplo de consultas: "Como reduzir o tempo de inicialização do cluster?" "Que tipo de plano de apoio eu tenho?" Respostas técnicas claras com trechos de código e links para a documentação relevante, quando necessário. Forneça sugestões contextuais e escalone para dar suporte aos engenheiros quando necessário.
Lógica do agente	Compreensão e classificação de consulta. Planejamento multietapa e tomada de decisões. Seleção e execução de ferramentas autônomas. Gerenciamento de estado e contexto entre interações. Tratamento de erros e mecanismos de fallback.	Planejamento alimentado por LLM com fallbacks determinísticos. Integre-se a um conjunto de ferramentas predefinidas (como recuperação de documentos ou ferramenta de recuperação do Salesforce). Mantenha o contexto da conversa para que haja interações coerentes em várias rodadas e uma recuperação robusta de erros.
Dados	Número e tipo de fontes de dados. Formato e localização de dados. Tamanho dos dados e frequência de atualização. Qualidade e consistência de dados.	Quatro fontes de dados. Documentação da empresa (HTML, PDF). Tíquetes de suporte resolvidos (JSON). Postagens do fórum da comunidade (tabela Delta). Conector do Salesforce. Dados armazenados no Catálogo do Unity e atualizados semanalmente. Tamanho total dos dados: 5 GB. Estrutura de dados consistente e qualidade mantida por equipes de documentação dedicada e suporte.
Desempenho	Latência máxima aceitável. Restrições de custo. Uso e simultaneidade esperados.	Requisito máximo de latência. Restrições de custo. Carga de pico esperada.
Avaliação	Disponibilidade do conjunto de dados de avaliação. Métricas de qualidade. Coleção de comentários do usuário.	Especialistas do assunto de cada área do produto ajudam a examinar as saídas e ajustar respostas incorretas para criar o conjunto de dados de avaliação. KPIs de negócios. Aumento na taxa de resolução de tíquetes de suporte. Diminuir o tempo gasto por usuário em cada chamado de suporte. Métricas de qualidade. Correção e relevância da resposta julgada por LLM. O LLM avalia a precisão de recuperação. Voto a favor ou voto contra do usuário. Coleção de comentários. O Slack será instrumentado para fornecer uma aprovação/desaprovação.
Segurança	Tratamento de dados confidenciais. Requisitos de controle de acesso.	Nenhum dado confidencial do cliente deve estar na fonte de recuperação. Autenticação do usuário por meio do SSO da Comunidade do Databricks.
Implantação	Integração com sistemas existentes. Implantação e controle de versão.	Integração com o sistema de tíquete de suporte. Agente implantado como um ponto de extremidade do Serviço de Modelo do Databricks.

Design da solução

Para obter considerações adicionais de design, consulte os padrões de design do sistema do Agente.

Fontes de dados e ferramentas

Ao criar um aplicativo de IA de geração, é importante identificar e mapear as várias fontes de dados e ferramentas necessárias para conduzir sua solução. Isso pode envolver conjuntos de dados estruturados, pipelines de processamento de dados não estruturados ou consulta de APIs externas. Abaixo estão as abordagens recomendadas para incorporar diferentes fontes de dados ou ferramentas em seu aplicativo de IA de geração:

Dados estruturados

Os dados estruturados geralmente residem em formatos tabulares bem definidos (por exemplo, uma tabela Delta ou arquivo CSV) e são ideais para tarefas em que as consultas são predeterminadas ou precisam ser geradas dinamicamente com base na entrada do usuário. Consulte Ferramentas de IA de recuperação estruturada para agentes para obter recomendações sobre como adicionar dados estruturados ao aplicativo de IA de geração.

Dados não estruturados

Os dados não estruturados incluem documentos brutos, PDFs, emails, imagens e outros formatos que não estão em conformidade com um esquema fixo. Esses dados exigem processamento adicional, normalmente por meio de uma combinação de análise, agrupamento e inserção, para serem efetivamente consultados e usados em um aplicativo de IA de geração. Consulte Ferramentas de criação e recuperação para dados não estruturados para obter recomendações sobre como adicionar dados estruturados ao seu aplicativo de IA generativa.

APIs externas e ações

Em alguns cenários, seu aplicativo de IA de geração pode precisar interagir com sistemas externos para recuperar dados ou executar ações. Nos casos em que seu aplicativo requer invocar ferramentas ou interagir com APIs externas, recomendamos o seguinte:

• Gerenciar credenciais de API com uma conexão de catálogo do Unity: Use uma Conexão de Catálogo do Unity para controlar com segurança as credenciais da API. Esse método garante que tokens e segredos sejam gerenciados centralmente e controlados pelo acesso.
• Invoque por meio do SDK do Databricks:
  Envie solicitações HTTP para serviços externos usando a http_request função da databricks-sdk biblioteca. Essa função aproveita uma conexão do Catálogo do Unity para autenticação e dá suporte a métodos HTTP padrão.
• Aproveite as funções de catálogo do Unity:
  Encapsular conexões externas em uma função do Catálogo do Unity para adicionar uma lógica personalizada de pré ou pós-processamento.
• Ferramenta executor do Python:
  Para executar dinamicamente o código para a transformação de dados ou interações de API usando funções do Python, use a ferramenta interna do executor do Python.

Exemplo:

Um aplicativo de análise interna recupera dados de mercado dinâmico de uma API financeira externa. O aplicativo usa:

• Conexão Externa do Catálogo do Unity para armazenar credenciais de API com segurança.
• Uma função personalizada do Catálogo do Unity encapsula a chamada à API para adicionar pré-processamento (como normalização de dados) e pós-processamento (como tratamento de erros).
• Além disso, o aplicativo pode invocar diretamente a API por meio do SDK do Databricks.

Abordagem de implementação

Ao desenvolver um aplicativo de IA de geração, você tem duas opções principais para implementar a lógica do agente: aproveitar uma estrutura de software livre ou criar uma solução personalizada usando código Python. Veja abaixo um detalhamento dos prós e contras para cada abordagem.

Usando uma estrutura (como LangChain, LlamaIndex, CrewAI ou AutoGen)

Vantagens:

• Componentes prontos para uso: As estruturas vêm com ferramentas prontas para gerenciamento de prompts, encadeamento de chamadas e integração com várias fontes de dados, o que pode acelerar o desenvolvimento.
• Comunidade e documentação: Aproveite o suporte da comunidade, tutoriais e atualizações regulares.
• Padrões de design comuns: As estruturas normalmente fornecem uma estrutura modular clara para orquestrar tarefas comuns, o que pode simplificar o design geral do agente.

Desvantagens:

• Abstração adicionada: As estruturas de software livre geralmente introduzem camadas de abstração que podem ser desnecessárias para seu caso de uso específico.
• Dependência de atualizações: Você pode depender dos mantenedores de estrutura para correções de bugs e atualizações de recursos, o que pode diminuir sua capacidade de se adaptar rapidamente aos novos requisitos.
• Sobrecarga potencial: A abstração extra pode levar a desafios de personalização se seu aplicativo precisar de um controle mais refinado.

Usando Python puro

Vantagens:

• Flexibilidade: O desenvolvimento em Python puro permite que você adapte sua implementação exatamente às suas necessidades sem ser restringido pelas decisões de design de uma estrutura.
• Adaptação rápida: Você pode ajustar rapidamente seu código e incorporar as alterações conforme necessário, sem aguardar atualizações de uma estrutura externa.
• Simplicidade: Evite camadas desnecessárias de abstração, o que pode resultar potencialmente em uma solução mais enxuta e com mais desempenho.

Desvantagens:

• Maior esforço de desenvolvimento: Criar do zero pode exigir mais tempo e experiência para implementar recursos que uma estrutura dedicada poderia fornecer de outra forma.
• Reinventando a roda: Talvez seja necessário desenvolver funcionalidades comuns (como encadeamento de ferramentas ou gerenciamento de prompts) por conta própria.
• Responsabilidade de manutenção: Todas as atualizações e correções de bugs se tornam sua responsabilidade, o que pode ser desafiador para sistemas complexos.

Por fim, sua decisão deve ser guiada pela complexidade do projeto, pelas necessidades de desempenho e pelo nível de controle necessário. Nenhuma abordagem é inerentemente superior; cada um oferece vantagens distintas dependendo de suas preferências de desenvolvimento e prioridades estratégicas.

1. Construir

Nesta fase, você transforma o design da solução em um aplicativo funcional de IA generativa. Em vez de aperfeiçoar tudo antecipadamente, comece pequeno com uma POC (prova de conceito) mínima que pode ser testada rapidamente. Isso permite que você implante em um ambiente de pré-produção o mais rápido possível, colete consultas representativas de usuários reais ou SMEs e refinar com base nos comentários do mundo real.

O processo de build segue estas etapas principais:

a. Preparar dados e ferramentas: Verifique se os dados necessários estão acessíveis, analisados e prontos para recuperação. Implementar ou registrar as funções e conexões do Catálogo do Unity (por exemplo, APIs de recuperação ou chamadas à API externa) de que o agente precisará. b. Compilar o agente: orquestre a lógica principal, começando com uma abordagem de POC simples. c. Verificação de qualidade: Valide a funcionalidade essencial antes de expor o aplicativo a mais usuários. d. Implantar agente de pré-produção: Disponibilize a POC para testar usuários e especialistas no assunto para comentários iniciais. e. Coletar comentários do usuário: Use o uso do mundo real para identificar áreas de melhoria, dados ou ferramentas adicionais necessários e possíveis refinamentos para a próxima iteração.

a. Preparar ferramentas e dados

Na fase de design da solução, você terá uma ideia inicial das fontes de dados e ferramentas necessárias para seu aplicativo. Neste estágio, mantenha-o mínimo: concentre-se apenas em dados suficientes para validar sua POC. Isso garante iteração rápida sem grandes investimentos iniciais em pipelines complexos.

Dados

1. Identificar um subconjunto representativo de dados
   • Para dados estruturados, selecione as principais tabelas ou colunas mais relevantes para o cenário inicial.
   • Para dados não estruturados, priorize a indexação apenas de um subconjunto de documentos representativos. Use um pipeline básico de agrupamento/inserção com o Mosaic AI Vector Search para que seu agente possa recuperar partes de texto relevantes, se necessário.
2. Configurar o acesso a dados
   • Se você precisar que seu aplicativo faça chamadas de API externas, armazene as credenciais com segurança usando uma conexão do Catálogo do Unity.
3. Validar a cobertura básica
   • Confirme se os subconjuntos de dados escolhidos abordam adequadamente as consultas de usuário que você planeja testar.
   • Salve quaisquer fontes de dados adicionais ou transformações complexas para iterações futuras. Sua meta atual deve ser provar a viabilidade básica e coletar comentários.

Ferramentas

Com suas fontes de dados configuradas, a próxima etapa é implementar e registrar as ferramentas que seu agente chamará em runtime para o Catálogo do Unity. Uma ferramenta é uma função de interação única, como uma consulta SQL ou uma chamada à API externa, que o agente pode invocar para recuperação, transformação ou ação.

Ferramentas de recuperação de dados

• Consultas de dados restritas e estruturadas: Se as consultas forem corrigidas, embrulhe-as em uma função SQL do Catálogo do Unity ou em uma UDF do Python. Isso mantém a lógica centralizada e detectável.
• Consultas de dados estruturadas e abertas: Se as consultas forem mais abertas, considere configurar um espaço do Genie para lidar com consultas de texto para SQL.
• Funções auxiliares de dados não estruturados: Para dados não estruturados armazenados no Mosaic AI Vector Search, crie uma ferramenta de recuperação de dados não estruturada que o agente pode chamar para buscar partes de texto relevantes.

Ferramentas de chamada de API

• Chamadas de API externas:chamadas à API podem ser invocadas diretamente usando o método do SDK do http_request Databricks.
• Wrappers opcionais: Se você precisar implementar a lógica de pré-processamento ou pós-processamento (como normalização de dados ou tratamento de erros), encapsule a chamada à API em uma função do Unity Catalog.

Mantenha-o mínimo

• Comece apenas com ferramentas essenciais: Concentre-se em um único caminho de recuperação ou em um conjunto limitado de chamadas à API. Você pode adicionar mais à medida que itera.
• Validar interativamente: Teste cada ferramenta de forma independente (por exemplo, em um notebook) antes de incorporá-la ao sistema de agente.

Depois que as ferramentas de protótipo estiverem prontas, prossiga para a criação do agente. O agente orquestra essas ferramentas para responder a consultas, buscar dados e executar ações conforme necessário.

b. Compilar o agente

Depois que seus dados e ferramentas estiverem prontos, você poderá criar o agente que responde a requisições recebidas, como consultas de usuário. Para criar um agente de protótipo inicial, use python ou playground de IA. Siga estas etapas:

1. Comece de forma simples
   • Escolha um padrão de design básico: Para uma POC, comece com uma cadeia básica (como uma sequência fixa de etapas) ou um único agente de chamada de ferramenta (em que o LLM pode chamar dinamicamente uma ou duas ferramentas essenciais).
     • Caso seu cenário esteja em sintonia com um dos notebooks de exemplo fornecidos na documentação do Databricks, use esse código como uma base estrutural.
   • Solicitação mínima: resista à vontade de criar solicitações super elaboradas nesta altura. Mantenha instruções sucintas e diretamente relevantes para suas tarefas iniciais.
2. Incorporar ferramentas
   • Integração de ferramentas: Se estiver usando um padrão de design de cadeia, as etapas que chamam cada ferramenta serão codificadas em código. Em um agente de chamada de ferramentas, você fornece um esquema para que o LLM saiba como invocar a função.
     • Valide se as ferramentas isoladas estão sendo executadas conforme o esperado, antes de incorporá-las ao sistema de agentes e testá-las de forma completa.
   • Guardrails: Se o agente puder modificar sistemas externos ou executar código, verifique se você tem verificações básicas de segurança e guardrails (como limitar o número de chamadas ou restringir determinadas ações). Implemente-os em uma função do Catálogo do Unity.
3. Rastrear e registrar o agente no MLflow
   • Rastrear cada etapa: Use o Rastreamento do MLflow para capturar entradas, saídas e tempo decorrido por etapa para depurar problemas e medir o desempenho.
   • Registre o agente em log: Use o MLflow Tracking para registrar em log o código e a configuração do agente.

Nesta fase, a perfeição não é o objetivo. Você quer um agente simples e funcional que possa implantar para um feedback inicial de usuários de teste e SMEs. A próxima etapa é executar uma verificação rápida de qualidade antes de disponibilizá-la em um ambiente de pré-produção.

c. Verificação de qualidade

Antes de expor o agente a um público pré-produção mais amplo, execute uma verificação de qualidade offline "boa o suficiente" para detectar problemas importantes antes de implantá-lo em um ponto de extremidade. Neste estágio, você normalmente não terá um conjunto de dados de avaliação grande e robusto, mas ainda pode fazer uma revisão rápida para garantir que o agente se comporte conforme o esperado em algumas consultas de exemplo.

1. Testar interativamente em um notebook
   • inspeção manual: chame manualmente o agente com solicitações representativas. Preste atenção se ele recupera os dados certos, chama as ferramentas corretamente e segue o formato desejado.
   • Inspecione os rastreamentos do MLflow: Se você habilitou o Rastreamento do MLflow, examine a telemetria passo a passo. Confirme se o agente escolhe as ferramentas apropriadas, lida com erros normalmente e não gera solicitações ou resultados intermediários inesperados.
   • Verifique a latência: Observe quanto tempo cada solicitação leva para ser executada. Se os tempos de resposta ou o uso do token forem muito altos, talvez seja necessário podar etapas ou simplificar a lógica antes de ir mais longe.
2. Verificação de vibração
   • Isso pode ser feito em um notebook ou no AI Playground.
   • Coerência e correção: A saída do agente faz sentido para as consultas que você testou? Há imprecisões gritantes ou detalhes ausentes?
   • Casos extremos: se você tentou algumas consultas fora do comum, o agente ainda respondeu de forma lógica ou pelo menos falhou de forma elegante (por exemplo, recusando educadamente a responder em vez de produzir uma saída sem sentido)?
   • Conformidade com o prompt: Se você forneceu instruções de alto nível, como tom desejado ou formatação, o agente está seguindo essas instruções?
3. Avaliar a qualidade "satisfatória"
   • Se você estiver limitado a consultas de teste neste momento, considere a geração de dados sintéticos. Consulte Criar um conjunto de avaliação.
   • Resolva os principais problemas: Se você descobrir falhas importantes (por exemplo, o agente chama repetidamente ferramentas inválidas ou gera absurdos), corrija esses problemas antes de expô-los a um público mais amplo. Veja problemas comuns de qualidade e como corrigi-los.
   • Decida sobre a viabilidade: Se o agente atender a um nível básico de usabilidade e correção para algumas consultas específicas, poderá prosseguir. Caso contrário, refina os prompts, corrija problemas de ferramentas ou dados e teste novamente.
4. Planejar as próximas etapas
   • Acompanhar melhorias: documente as deficiências que você decidir adiar. Depois de coletar feedbacks do mundo real na pré-produção, você poderá revisitá-los.

Se tudo parecer viável para um lançamento limitado, você estará pronto para implantar o agente em pré-produção. Um processo de avaliação completo ocorrerá em fases posteriores, especialmente depois que você tiver dados mais reais, comentários de SME e um conjunto de avaliação estruturado. Por enquanto, concentre-se em garantir que seu agente demonstre de forma confiável sua funcionalidade principal.

d. Implantar agente em pré-produção

Depois que o agente atingir um limite de qualidade de linha de base, a próxima etapa é hospedá-lo em um ambiente de pré-produção para que você possa entender como os usuários consultam o aplicativo e coletam seus comentários para orientar o desenvolvimento. Esse ambiente pode ser seu ambiente de desenvolvimento durante a fase de POC. O principal requisito é que o ambiente esteja acessível para selecionar testadores internos ou especialistas em domínio.

1. Implantar o agente
   • Registrar e registrar o agente: Primeiro, registre o agente como um modelo do MLflow e registre-o no Catálogo do Unity.
   • Implantar usando o Agent Framework: Use o Agent Framework para pegar o agente registrado e implantá-lo como um endpoint de Model Serving.
2. Tabelas de inferências
   • O Agent Framework armazena automaticamente solicitações, respostas e rastreamentos, juntamente com metadados, em uma tabela de inferência no Catálogo do Unity para cada endpoint de serviço.
3. Proteger e configurar
   • Controle de acesso:Restrinja o acesso de endpoints ao seu grupo de teste (SMEs, usuários avançados). Isso garante o uso controlado e evita a exposição inesperada de dados.
   • Autenticação: confirme se todos os segredos necessários, tokens de API ou conexões de banco de dados estão configurados corretamente.

Agora você tem um ambiente controlado para coletar comentários sobre consultas reais. Uma das maneiras pelas quais você pode interagir rapidamente com o agente é no AI Playground, onde você pode selecionar o ponto de extremidade do Model Serving recém-criado e consultar o agente.

e. Coletar comentários do usuário

Depois de implantar seu agente em um ambiente de pré-produção, a próxima etapa é coletar comentários de usuários reais e SMEs para descobrir lacunas, detectar imprecisões e refinar ainda mais seu agente.

1. Usar o Aplicativo de Revisão

   • Quando você implanta seu agente com o Agent Framework, um aplicativo de revisão simples no estilo chat é criado. Ele fornece uma interface amigável, em que os testadores podem fazer perguntas e classificar imediatamente as respostas do agente.
   • Todas as solicitações, respostas e feedbacks dos usuários (avaliações positivas/negativas, comentários escritos) são automaticamente registrados em uma tabela de inferência, facilitando a análise posterior.

2. Usar a interface do usuário de monitoramento para inspecionar logs

   • Acompanhe as curtidas/descurtidas ou o feedback textual na Interface de Monitoramento para ver quais respostas os responsáveis pelos testes consideraram particularmente útil (ou não).

3. Envolver especialistas em domínio

   • Incentive os SMEs a executar cenários típicos e incomuns. O conhecimento de domínio ajuda a exibir erros sutis, como interpretações incorretas da política ou dados ausentes.
   • Mantenha uma lista de problemas pendentes, desde pequenos ajustes de solicitações até refatorações maiores do pipeline de dados. Decida quais correções priorizar antes de seguir em frente.

4. Coletar novos dados de avaliação

   • Converta interações notáveis ou problemáticas em casos de teste. Ao longo do tempo, elas formam a base de um conjunto de dados de avaliação mais robusto.
   • Se possível, adicione respostas corretas ou esperadas a esses casos. Isso ajuda a medir a qualidade nos ciclos de avaliação subsequentes.

5. Iterar com base nos comentários

   • Aplique correções rápidas, como pequenas alterações de solicitação ou novas diretrizes para resolver problemas imediatos.
   • Para problemas mais complexos, como exigir lógica avançada de várias etapas ou novas fontes de dados, reúna evidências suficientes antes de investir em grandes mudanças arquitetônicas.

Aproveitando os comentários do Aplicativo de Revisão, dos logs da tabela de inferência e dos insights de SME, essa fase de pré-produção ajuda a identificar lacunas importantes e a refinar seu agente de forma iterativa. As interações do mundo real coletadas nesta etapa criam a base para a criação de um conjunto de avaliação estruturada, permitindo que você faça a transição de melhorias ad hoc para uma abordagem mais sistemática para a medição da qualidade. Depois que os problemas recorrentes forem resolvidos e o desempenho se estabilizar, você estará bem preparado para uma implantação de produção com avaliação robusta em vigor.

2. Avaliar e Iterar

Depois que seu aplicativo de IA de geração tiver sido testado em um ambiente de pré-produção, a próxima etapa é medir, diagnosticar e refinar sistematicamente sua qualidade. Essa fase "avaliar e iterar" transforma o feedback e logs brutos em um conjunto de avaliação estruturado, permitindo que você teste as melhorias repetidamente e garantindo que seu aplicativo atenda aos padrões necessários em termos de precisão, relevância e segurança.

Esta fase inclui as seguintes etapas:

• Coletar consultas reais dos logs: converta interações problemáticas ou de alto valor de suas tabelas de inferência em casos de teste.
• Adicione rótulos de especialista: Sempre que possível, anexe verdades básicas ou diretrizes de estilo e política a esses casos para que você possa medir a correção, a fundamentação e outras dimensões de qualidade de forma mais objetiva.
• Aproveite a avaliação do agente: Use juízes de LLM internos ou verificações personalizadas para quantificar a qualidade do aplicativo.
• Iterar: aprimore a qualidade refinando a lógica, os pipelines de dados ou as solicitações (prompts) do seu agente. Execute novamente a avaliação para confirmar se você resolveu os principais problemas.

Observe que esses recursos funcionam mesmo que seu aplicativo de IA de geração seja executado fora do Databricks. Ao instrumentar seu código com o Rastreamento do MLflow, você pode capturar rastreamentos de qualquer ambiente e unificá-los na Plataforma de Inteligência de Dados do Databricks para avaliação e monitoramento consistentes. À medida que você continua incorporando novas consultas, comentários e insights de SME, seu conjunto de dados de avaliação se torna um recurso vivo que sustenta um ciclo de melhoria contínua, garantindo que seu aplicativo de IA de geração permaneça robusto, confiável e alinhado com as metas de negócios.

a. Avaliar o agente

Depois que o agente estiver em execução em um ambiente de pré-produção, a próxima etapa é medir sistematicamente seu desempenho além das verificações de vibe ad hoc. A Avaliação do Agente de IA do Mosaico permite que você crie conjuntos de avaliação, execute verificações de qualidade com juízes de LLM internos ou personalizados e itere rapidamente em áreas problemáticas.

Avaliações offline e online

Ao avaliar aplicativos de IA de geração, há duas abordagens principais: avaliação offline e avaliação online. Esta fase do ciclo de desenvolvimento se concentra na avaliação offline, que se refere à avaliação sistemática fora das interações dinâmicas do usuário. A avaliação online será abordada mais adiante ao discutir o monitoramento do agente em produção.

As equipes geralmente dependem muito do "teste de vibe" no fluxo de trabalho do desenvolvedor, tentando informalmente umas consultas e avaliando subjetivamente se as respostas parecem razoáveis. Embora isso forneça um ponto de partida, ele não tem o rigor e a cobertura necessários para criar aplicativos de qualidade de produção.

Por outro lado, um processo de avaliação offline adequado faz o seguinte:

• Estabelece uma linha de base de qualidade antes da implantação mais ampla, criando métricas claras a serem direcionadas para melhoria.
• Identifica pontos fracos específicos que exigem atenção, ultrapassando a limitação de testar apenas os casos de uso esperados.
• Detecta regressões de qualidade à medida que você refina seu aplicativo comparando automaticamente o desempenho entre versões.
• Fornece métricas quantitativas para demonstrar melhorias às partes interessadas.
• Ajuda a descobrir casos de exceção e possíveis modos de falha antes dos usuários.
• Reduz o risco de implantar um agente com baixo desempenho na produção.

Investir tempo na avaliação offline paga dividendos significativos a longo prazo, ajudando você a impulsionar a entrega de respostas consistentemente de alta qualidade.

Criar um conjunto de avaliação

Um conjunto de avaliação serve como base para medir o desempenho do seu aplicativo de IA generativa. Semelhante a um conjunto de testes no desenvolvimento de software tradicional, essa coleção de consultas representativas e respostas esperadas torna-se seu conjunto de dados de teste de regressão e parâmetro de qualidade.

Você pode criar um conjunto de avaliação por meio de várias abordagens complementares:

1. Transformar logs de tabela de inferência em exemplos de avaliação

   Os dados de avaliação mais valiosos vêm diretamente do uso real. Sua implantação prévia à produção gerou registros de tabela de inferência que contêm contexto recuperado, solicitações, respostas do agente e chamadas de ferramenta.

   Converter esses logs em um conjunto de avaliação oferece várias vantagens:

   • Cobertura do mundo real: Comportamentos imprevisíveis do usuário que talvez você não tenha previsto estão incluídos.
   • Focado em problemas: Você pode filtrar especificamente para comentários negativos ou respostas lentas.
   • Distribuição representativa: A frequência real de diferentes tipos de consulta é capturada.

2. Gerar dados de avaliação sintética

   Se você não tiver um conjunto coletado de consultas de usuário, poderá gerar automaticamente um conjunto de dados de avaliação sintética. Esse "conjunto inicial" de consultas ajuda você a avaliar rapidamente se o agente:

   • Retorna respostas coerentes e precisas.
   • Responder no formato correto.
   • Respeita a estrutura, a tonalidade e as diretrizes políticas.
   • Recupera corretamente o contexto (para RAG).

   Os dados sintéticos normalmente não são perfeitos. Pense nisso como um trampolim temporário. Você também desejará:

   • Peça para PMEs ou especialistas no assunto revisarem e eliminarem quaisquer consultas irrelevantes ou repetitivas.
   • Substitua ou aumente-o mais tarde por logs de uso do mundo real.

3. Selecione consultas manualmente

   Se você preferir não depender de dados sintéticos ou ainda não tiver logs de inferência, identifique de 10 a 15 consultas reais ou representativas e crie um conjunto de avaliação com base nelas. Consultas representativas podem vir de entrevistas com usuários ou de sessões de brainstorming com desenvolvedores. Até mesmo uma lista curta e curada pode expor falhas gritantes nas respostas do agente.

Essas abordagens não são mutuamente exclusivas, mas complementares. Um conjunto de avaliação eficaz evolui ao longo do tempo e normalmente combina exemplos de várias fontes, incluindo o seguinte:

• Comece com exemplos coletados manualmente para testar a funcionalidade principal.
• Opcionalmente, adicione dados sintéticos para ampliar a cobertura antes que você tenha dados reais do usuário.
• Incorpore gradualmente os logs do mundo real à medida que ficam disponíveis.
• Atualize continuamente com novos exemplos que refletem a alteração dos padrões de uso.

Práticas recomendadas para consultas de avaliação

Ao criar seu conjunto de avaliação, inclua deliberadamente diversos tipos de consulta, como o seguinte:

• Padrões de uso esperados e inesperados (como solicitações muito longas ou curtas).
• Possíveis tentativas de uso indevido ou ataques de injeção de solicitação (como tentativas de revelar o prompt do sistema).
• Consultas complexas que exigem várias etapas de raciocínio ou chamadas de ferramenta.
• Casos extremos com informações mínimas ou ambíguas (como erros ortográficos ou consultas vagas).
• Exemplos que representam diferentes níveis de habilidade do usuário e planos de fundo.
• Consultas que testam possíveis vieses em respostas (como "comparar Empresa A versus Empresa B").

Lembre-se de que seu conjunto de avaliação deve crescer e evoluir junto com seu aplicativo. À medida que você descobre novos modos de falha ou comportamentos do usuário, adicione exemplos representativos para garantir que seu agente continue a melhorar nessas áreas.

Adicionar critérios de avaliação

Cada exemplo de avaliação deve ter critérios para avaliar a qualidade. Esses critérios servem como padrões em relação aos quais as respostas do agente são medidas, permitindo a avaliação objetiva em várias dimensões de qualidade.

Fatos verdadeiros ou respostas de referência

Ao avaliar a precisão factual, há duas abordagens principais: fatos esperados ou respostas de referência. Cada um tem uma finalidade diferente em sua estratégia de avaliação.

Usar fatos esperados (recomendado)

A abordagem expected_facts envolve a listagem dos principais fatos que devem aparecer em uma resposta correta. Para obter um exemplo, consulte Exemplo de avaliação definido com request, responsee guidelinesexpected_facts.

Essa abordagem oferece vantagens significativas:

• Permite flexibilidade na forma como os fatos são expressos na resposta.
• Torna mais fácil para os SMEs fornecer a verdade básica.
• Acomoda diferentes estilos de resposta, garantindo que as informações principais estejam presentes.
• Habilita uma avaliação mais confiável entre versões de modelo ou configurações de parâmetro.

O juiz de correção interno verifica se a resposta do agente incorpora esses fatos essenciais, independentemente de frases, ordenações ou conteúdo adicional.

Usar a resposta esperada (alternativa)

Como alternativa, você pode fornecer uma resposta de referência completa. Essa abordagem funciona melhor nas seguintes situações:

• Você tem respostas padrão ouro criadas por especialistas.
• A redação exata ou a estrutura da resposta importa.
• Você está avaliando respostas em contextos altamente regulamentados.

O Databricks geralmente recomenda usar expected_facts over expected_response porque ele fornece mais flexibilidade e, ao mesmo tempo, garante a precisão.

Diretrizes para conformidade de estilo, tom ou política

Além da precisão factual, talvez seja necessário avaliar se as respostas seguem requisitos específicos de estilo, tom ou política.

Somente diretrizes

Se sua principal preocupação é impor requisitos de estilo ou política em vez de precisão factual, você pode fornecer diretrizes sem os fatos esperados:

# Per-query guidelines
eval_row = {
    "request": "How do I delete my account?",
    "guidelines": {
        "tone": ["The response must be supportive and non-judgmental"],
        "structure": ["Present steps chronologically", "Use numbered lists"]
    }
}

# Global guidelines (applied to all examples)
evaluator_config = {
    "databricks-agent": {
        "global_guidelines": {
            "rudeness": ["The response must not be rude."],
            "no_pii": ["The response must not include any PII information (personally identifiable information)."]
        }
    }
}

O avaliador de diretrizes do LLM interpreta essas instruções em linguagem natural e avalia se a resposta está de acordo com elas. Isso funciona particularmente bem para dimensões de qualidade subjetivas, como tom, formatação e adesão às políticas organizacionais.

Combinando a verdade e as diretrizes básicas

Para uma avaliação abrangente, você pode combinar verificações de precisão factuais com diretrizes de estilo. Consulte Conjuntos de avaliação de exemplo com request, response, guidelines e expected_facts. Essa abordagem garante que as respostas sejam factualmente precisas e sigam os padrões de comunicação da sua organização.

Usar respostas pré-capturadas

Se você já capturou pares de solicitação-resposta do desenvolvimento ou teste, poderá avaliá-los diretamente sem invocar o agente. Isso é útil para:

• Analisando padrões existentes no comportamento do agente.
• Comparação do desempenho com versões anteriores.
• Economizando tempo e custos não regenerando respostas.
• Avaliação de um agente atendido fora do Databricks.

Para obter detalhes sobre como fornecer as colunas relevantes em seu DataFrame de avaliação, consulte Exemplo: Como passar saídas geradas anteriormente para a Avaliação do Agente. A Avaliação do Agente de IA do Mosaico usa esses valores pré-capturados em vez de chamar seu agente novamente, enquanto ainda aplica as mesmas verificações e métricas de qualidade.

Práticas recomendadas para critérios de avaliação

Ao definir seus critérios de avaliação:

1. Seja específico e objetivo: Defina critérios claros e mensuráveis que diferentes avaliadores interpretariam da mesma forma.
   • Considere adicionar métricas personalizadas para medir os critérios de qualidade que são importantes para você.
2. Concentre-se no valor do usuário: Priorize os critérios que se alinham com o que mais importa para seus usuários.
3. Inicie simples: Comece com um conjunto principal de critérios e expanda à medida que sua compreensão das necessidades de qualidade aumenta.
4. Cobertura equilibrada: Inclua critérios que abordem diferentes aspectos de qualidade (por exemplo, precisão factual, estilo e segurança).
5. Iterar com base no feedback: Refine seus critérios com base no feedback dos usuários e nos requisitos em evolução.

Consulte as práticas recomendadas para desenvolver um conjunto de avaliação para obter mais informações sobre como criar conjuntos de dados de avaliação de alta qualidade.

Executar avaliações

Agora que você preparou um conjunto de avaliação com consultas e critérios, você pode executar uma avaliação usando mlflow.evaluate(). Essa função manipula todo o processo de avaliação, desde invocar seu agente até analisar os resultados.

Fluxo de trabalho de avaliação básica

Executar uma avaliação básica requer apenas algumas linhas de código. Para obter detalhes, consulte Executar uma avaliação.

Quando a avaliação é iniciada:

1. Para cada linha em seu conjunto de avaliação, mlflow.evaluate() faz o seguinte:
   • Chama seu agente com a consulta (se você ainda não forneceu uma resposta).
   • Aplica juízes de LLM integrados para avaliar critérios de qualidade.
   • Calcula métricas operacionais como uso de token e latência.
   • Registra lógicas detalhadas para cada avaliação.
2. Os resultados são registrados automaticamente no MLflow, criando:
   • Avaliações de qualidade por linha.
   • Métricas agregadas em todos os exemplos.
   • Logs detalhados para depuração e análise.

Personalizar a avaliação

Você pode adaptar a avaliação às suas necessidades específicas usando parâmetros adicionais. O evaluator_config parâmetro permite que você faça o seguinte:

• Selecione quais juízes integrados executar.
• Defina diretrizes globais que se aplicam a todos os exemplos.
• Configurar limites para juízes.
• Forneça poucos exemplos para orientar as avaliações do juiz.

Para obter detalhes e exemplos, consulte Exemplos.

Avaliar agentes fora do Databricks

Um recurso poderoso da Avaliação do Agente é sua capacidade de avaliar aplicativos de IA de geração implantados em qualquer lugar, não apenas no Databricks.

Quais avaliadores são aplicados

Por padrão, a Avaliação do Agente seleciona automaticamente os juízes LLM apropriados com base nos dados disponíveis no conjunto de avaliação. Para obter detalhes sobre como a qualidade é avaliada, consulte Como a qualidade é avaliada pelos juízes de LLM.

Analisar os resultados da avaliação

Depois de executar uma avaliação, a interface do usuário do MLflow fornece visualizações e insights para entender o desempenho do aplicativo. Essa análise ajuda você a identificar padrões, diagnosticar problemas e priorizar melhorias.

Navegar pelos resultados da avaliação

Ao abrir a interface do usuário do MLflow após a execução mlflow.evaluate(), , você encontrará várias exibições interconectadas. Para obter informações sobre como navegar por esses resultados na interface do usuário do MLflow, consulte Examinar a saída usando a interface do usuário do MLflow.

Para obter diretrizes sobre como interpretar padrões de falha, consulte b. Aprimorar o agente e as ferramentas.

Métricas e juízes de IA personalizados

Embora os juízes internos cobrem muitas verificações comuns (como correção, estilo, política e segurança), talvez seja necessário avaliar aspectos específicos do domínio do desempenho do aplicativo. Juízes e métricas personalizados permitem que você estenda os recursos de avaliação para atender aos seus requisitos de qualidade exclusivos.

Juízes de LLM personalizados

Para obter detalhes sobre como criar um juiz LLM personalizado a partir de um prompt, consulte Criar juízes de IA a partir de um prompt.

Os juízes personalizados se destacam na avaliação de dimensões de qualidade subjetivas ou com nuances que se beneficiam do julgamento humano, como:

• Conformidade específica do domínio (legal, médica, financeira).
• Estilo de voz e comunicação da marca.
• Sensibilidade e adequação culturais.
• Qualidade de raciocínio complexa.
• Convenções de escrita especializadas.

Os resultados do juiz aparecem na interface do usuário do MLflow junto aos juízes integrados, com as mesmas justificativas detalhadas explicando as avaliações.

Métricas personalizadas

Para avaliações mais programáticas e determinísticas, você pode criar métricas personalizadas usando o @metric decorador. Consulte o decorador @metric.

As métricas personalizadas são ideais para:

• Verificando requisitos técnicos, como validação de formato e conformidade de esquema.
• Verificando a presença ou ausência de conteúdo específico.
• Executando medidas quantitativas, como pontuações de complexidade ou comprimento da resposta.
• Implementando regras de validação específicas aos negócios.
• Integração com sistemas de validação externos.

b. Melhorar o agente e as ferramentas

Depois de executar a avaliação e identificar problemas de qualidade, a próxima etapa é resolver sistematicamente esses problemas para melhorar o desempenho. Os resultados da avaliação fornecem informações valiosas sobre onde e como seu agente está falhando, permitindo que você faça melhorias direcionadas em vez de ajustes aleatórios.

Problemas comuns de qualidade e como corrigi-los

As avaliações dos juízes de LLM dos seus resultados de avaliação apontam para tipos específicos de falhas em seu sistema de agentes. Esta seção explora esses padrões comuns de falha e suas soluções. Para obter informações sobre como interpretar resultados da avaliação do LLM, consulte Resultados do juiz de IA.

Práticas recomendadas de iteração de qualidade

À medida que você itera em melhorias, mantenha uma documentação rigorosa. Por exemplo:

1. Controle suas alterações
   • Registre cada iteração significativa usando o MLflow Tracking.
   • Salve prompts, configurações e parâmetros de chave em um arquivo de configuração central. Verifique se isso está registrado pelo agente.
   • Para cada novo agente implantado, mantenha uma lista de alterações no repositório detalhando o que mudou e por quê.
2. Documente o que funcionou e não funcionou
   • Documente abordagens bem-sucedidas e malsucedidas.
   • Observe o impacto específico de cada alteração nas métricas. Vincule de volta à execução de Avaliação do Agente no MLflow.
3. Alinhar com as partes interessadas
   • Use o Aplicativo de Revisão para validar melhorias com SMEs.
     • Comunique alterações aos revisores usando instruções do revisor.
   • Para uma comparação lado a lado de diferentes versões de um agente, pense em criar vários pontos de extremidade de agente e usar o modelo no Playground de IA. Isso permite que os usuários enviem a mesma solicitação para diferentes endpoints e examinem a resposta e os rastreios lado a lado.

3. Produção

Depois de avaliar e melhorar iterativamente seu aplicativo, você atingiu um nível de qualidade que atende aos seus requisitos e está pronto para uso mais amplo. A fase de produção envolve implantar seu agente refinado em seu ambiente de produção e implementar o monitoramento contínuo para manter a qualidade ao longo do tempo.

A fase de produção inclui:

• Implantar o agente na produção: Configure um endpoint pronto para produção com as configurações apropriadas de segurança, escalabilidade e autenticação.
• Monitorar o agente em produção: estabeleça uma avaliação contínua de qualidade, acompanhamento de desempenho e alertas para garantir que seu agente mantenha uma alta qualidade e confiabilidade quando usado no mundo real.

Isso cria um ciclo de feedback contínuo, no qual os insights gerados pelo monitoramento impulsionam melhorias adicionais, que você pode testar, implantar e continuar monitorando. Essa abordagem garante que seu aplicativo permaneça de alta qualidade, em conformidade e alinhado com as necessidades comerciais em evolução ao longo de seu ciclo de vida.

a. Implantar agente em produção

Depois de concluir a avaliação completa e o aprimoramento iterativo, você estará pronto para implantar seu agente em um ambiente de produção. [Mosaic AI Agent Framework](/generative-ai/agent-framework/build-gen AI-apps.md#agent-framework) simplifica esse processo lidando com muitas preocupações de implantação automaticamente.

Processo de implantação

A implantação do agente na produção envolve as seguintes etapas:

1. Faça login e registre seu agente como um modelo de MLflow no Unity Catalog.
2. Implante o agente usando o Agent Framework.
3. Configure a autenticação para todos os recursos dependentes que seu agente precisa acessar.
4. Teste a implantação para verificar a funcionalidade no ambiente de produção.
   • Depois que o endpoint de serviço do modelo estiver pronto, você poderá interagir com o agente no IA Playground, onde poderá testar e verificar sua funcionalidade.

Para obter etapas detalhadas de implementação, consulte Implantar um agente para aplicativos de IA generativos.

Considerações sobre implantação de produção

À medida que você passa para a produção, tenha em mente as seguintes considerações principais:

Desempenho e dimensionamento

• Balancee o custo versus o desempenho com base nos padrões de uso esperados.
• Considere habilitar reduzir para zero para agentes usados intermitentemente para reduzir custos.
• Entenda os requisitos de latência com base nas necessidades de experiência do usuário do aplicativo.

Governança e segurança

• Assegure os controles de acesso corretos no nível do Unity Catalog para todos os componentes do agente.
• Use a passagem de autenticação interna para recursos do Databricks sempre que possível.
• Configure o gerenciamento de credenciais apropriado para APIs externas ou fontes de dados.

Abordagem de integração

• Determine como seu aplicativo interagirá com o agente (por exemplo, usando uma API ou uma interface inserida).
• Considere como lidar e exibir respostas do agente em seu aplicativo.
  • Se o aplicativo cliente precisar de contexto adicional (como referências de documento de origem ou pontuações de confiança), projete o agente para incluir esses metadados em suas respostas (por exemplo, usando saídas personalizadas).
• Planeje o tratamento de erros e mecanismos de fallback para quando o agente não estiver disponível.

Coleção de comentários

• Aproveite o Aplicativo de Revisão para comentários dos participantes durante a distribuição inicial.
• Crie mecanismos para coletar comentários do usuário diretamente em sua interface do aplicativo.
  • O ponto de extremidade de comentários criado para coletar comentários do Aplicativo de Revisão também pode ser usado por aplicativos externos para fornecer comentários sobre o agente. Veja Fornecer feedback sobre um agente implantado.
• Verifique se os dados de comentários fluem em seu processo de avaliação e melhoria.

b. Monitorar o agente em produção

Depois que o agente é implantado na produção, é essencial monitorar continuamente seus padrões de desempenho, qualidade e uso. Ao contrário do software tradicional em que a funcionalidade é determinística, os aplicativos de IA generativa podem exibir variação de qualidade ou comportamentos inesperados quando encontram entradas do mundo real. O monitoramento eficaz permite detectar problemas antecipadamente, entender os padrões de uso e melhorar continuamente a qualidade do aplicativo.

Configurar o monitoramento do agente

A IA do Mosaico fornece recursos de monitoramento internos que permitem acompanhar o desempenho do agente sem criar uma infraestrutura de monitoramento personalizada:

1. Crie um monitor para o agente implantado.
2. Configure a taxa de amostragem e a frequência com base nas necessidades de volume e monitoramento de tráfego.
3. Selecione métricas de qualidade para avaliar automaticamente em solicitações de exemplo.

Dimensões principais de monitoramento

Em geral, o monitoramento efetivo deve abranger três dimensões críticas:

1. Métricas operacionais

   • Volume e padrões de solicitações.
   • Latência de resposta.
   • Taxas e tipos de erro.
   • Uso e custos de token.

2. Métricas de qualidade

   • Relevância para consultas de usuário.
   • Fundamentação no contexto recuperado.
   • Segurança e conformidade com as diretrizes.
   • Taxa de aprovação geral de qualidade.

3. Comentários do usuário

   • Feedback explícito (positivo/negativo).
   • Sinais implícitos (perguntas de acompanhamento, conversas abandonadas).
   • Problemas relatados aos canais de suporte.

Utilize a interface de monitoramento

A interface do usuário de monitoramento fornece insights visualizados sobre essas dimensões em duas guias.

• Guia Gráficos: Exibir tendências em volume de solicitação, métricas de qualidade, latência e erros ao longo do tempo.
• Guia Logs: examine solicitações e respostas individuais, incluindo seus resultados de avaliação.

Os recursos de filtragem permitem que os usuários pesquisem consultas específicas ou filtrem por resultado de avaliação. Para obter mais informações, consulte o que é o Monitoramento do Lakehouse para IA generativa? (MLflow 2).

Criar painéis e alertas

Para monitoramento abrangente:

• Crie painéis personalizados usando os dados de monitoramento armazenados na tabela de rastreamentos avaliada.
• Configure alertas para a qualidade crítica ou os limites operacionais.
• Agende revisões regulares de qualidade com as principais partes interessadas.

Ciclo de melhoria contínua

Monitoramento é mais valioso quando ele retroalimenta seu processo de melhoria.

1. Identifique problemas por meio do monitoramento de métricas e comentários do usuário.
2. Exporte exemplos problemáticos para o conjunto de avaliação.
3. Diagnosticar causas raiz usando a análise de rastreamento do MLflow e os resultados do avaliador de LLM (conforme discutido em Problemas comuns de qualidade e como corrigi-los).
4. Desenvolva e teste melhorias em relação ao conjunto de avaliação expandido.
5. Implante atualizações e monitore o impacto.

Essa abordagem iterativa e de loop fechado ajuda a garantir que seu agente continue a melhorar com base nos padrões de uso do mundo real, mantendo a alta qualidade enquanto se adapta aos requisitos e comportamentos do usuário em mudança. Com o Monitoramento do Agente, você obtém visibilidade de como seu agente está se saindo em produção, permitindo que você resolva proativamente os problemas e otimize a qualidade e o desempenho.