Fluxo de trabalho do desenvolvedor de aplicativos de IA generativa

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

0. Pré-requisitos

• Colete requisitos para validar a adequação da IA generativa e identificar restrições.
• Projete sua arquitetura de solução.

1. Construa

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

2. Avaliar & Iterar

• Colete feedback dos usuários e meça a qualidade
• Corrija problemas de qualidade refinando a lógica e as ferramentas do agente com base na avaliação.
• Incorpore informações de especialistas no assunto (SME) para melhorar continuamente a qualidade do sistema de agentes.

3. Produção

• Implante a aplicação 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, acionando atualizações no projeto do agente e outra rodada de avaliação. Seguindo essas etapas sistematicamente e aproveitando os recursos de rastreamento de MLflow, Agent Framework e Avaliação de Agente do Databricks, você pode criar aplicativos de IA de geração 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 melhorar ao longo do tempo.

0. Pré-requisitos

Antes de começar a desenvolver seu aplicativo de IA de geração, não se pode exagerar o quão importante é ter tempo para fazer o seguinte corretamente: reunir requisitos e projetar soluções.

Reunir requisitos inclui as seguintes etapas:

• Valide se a IA de geração se encaixa no seu caso de uso.
• Defina a experiência do usuário.
• Definir o escopo das fontes de dados.
• Defina restrições de desempenho.
• Capture restrições de segurança.

Design da solução inclui o seguinte:

• Mapeie pipelines de dados.
• Identificar as ferramentas necessárias.
• Descreva a arquitetura geral do sistema.

Ao estabelecer essas bases, você define uma direção clara para os estágios subsequentes de Construir, Avaliare Produção .

Reunir requisitos

Definir requisitos de casos de uso claros e abrangentes é um primeiro passo crítico no desenvolvimento de seu aplicativo de IA de geração bem-sucedido. Estes requisitos servem os seguintes objetivos:

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

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

O caso de uso é adequado para a 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 suas necessidades. Alguns exemplos em que uma solução de IA generativa é uma boa opção incluem:

• Geração de conteúdo: A tarefa requer gerar conteúdo novo ou criativo que não pode ser alcançado com modelos estáticos ou lógica simples baseada em regras.
• Tratamento dinâmico de consultas: As consultas do usuário são abertas ou complexas e exigem respostas flexíveis e sensíveis ao contexto.
• Síntese da informação: O caso de uso se beneficia da combinação ou resumo de diversas fontes de informação para produzir um resultado coerente.
• Agent Systems: O aplicativo requer mais do que apenas gerar texto em resposta a um prompt. Pode ter de ser capaz de:
  • Planeamento e tomada de decisão: Formulação de uma estratégia em várias etapas para atingir um objetivo específico.
  • Tomada de ações: Acionar processos externos ou recorrer a várias ferramentas para executar tarefas (por exemplo, recuperar dados, fazer chamadas de API, executar consultas SQL, executar código).
  • Manter o estado: Acompanhar o histórico de conversas ou o contexto de tarefas em várias interações para permitir a continuidade.
  • Produzir resultados adaptativos: Gerar respostas que evoluem com base em ações anteriores, informações atualizadas ou condições em mudança.

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ático ou se encaixa dentro de uma estrutura simples e fechada.
• São necessárias respostas de latência extremamente baixa (milissegundos) e a sobrecarga do processamento generativo não pode ser acomodada.
• Respostas simples e modeladas são suficientes para o caso de uso pretendido.

Importante

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

• 🟢 [P0] itens são críticos ou essenciais. Estes problemas devem ser resolvidos imediatamente.
• 🟡 itens de [P1] são importantes, mas podem seguir após os requisitos de P0.
• ⚪ [P2] itens são considerações de prioridade mais baixa ou melhorias que podem ser abordadas à medida que o tempo e os recursos permitem.

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

Experiência do utilizador

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

• 🟢 [P0] Pedido típico: Qual será o aspeto de um pedido de utilizador típico? Reúna exemplos das partes interessadas.
• 🟢 [P0] Respostas esperadas: Que tipo de respostas o sistema deve gerar (por exemplo, respostas curtas, explicações longas, narrativas criativas)?
• 🟡 [P1] Modalidade de interação: Como os usuários irão interagir com o aplicativo (por exemplo, interface de chat, barra de pesquisa, assistente de voz)?
• 🟡 [P1] Tom, estilo, estrutura: Que tom, estilo e estrutura os resultados gerados devem adotar (formal, conversacional, técnica, pontos de tópicos ou prosa contínua)?
• 🟡 [P1]Tratamento de erros: Como o aplicativo deve lidar com consultas ambíguas, incompletas ou fora do destino? Deve fornecer feedback ou solicitar esclarecimentos?
• ⚪ [P2] Requisitos de formatação: Existem diretrizes específicas de formatação ou apresentação para os resultados (incluindo metadados ou informações suplementares)?

Dados

Determine a natureza, fonte(s) e qualidade dos dados que serão usados no aplicativo de IA de geração.

• 🟢 [P0] Fontes de dados: Que fontes de dados estão disponíveis?
  • Para cada fonte, determinar:
    • Os dados são estruturados ou não estruturados?
    • Qual é o formato de origem (por exemplo, PDF, HTML, JSON, XML)?
    • Onde residem os dados?
    • Quantos dados estão disponíveis?
    • Como devem ser acedidos os dados?
• 🟡 [P1] Atualizações de dados: Com que frequência os dados são atualizados? Que mecanismos estão em vigor para lidar com atualizações?
• 🟡 [P1] Qualidade dos dados: Existem problemas de qualidade conhecidos ou inconsistências?
  • Ponderar se será necessário um controlo da qualidade das fontes de dados.

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

Fonte de dados	Fonte	Tipo(s) de ficheiro(s)	Tamanho	Frequência de atualização
Fonte de dados 1	Volume do catálogo Unity	JSON	10GB	Diariamente
Fonte de dados 2	API pública	XML	NA (API)	Em tempo real
Fonte de dados 3	SharePoint	PDF, .docx	500MB	Mensal

Restrições de desempenho

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

Latência

• 🟢 [P0] Time-to-first 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 caso.
• 🟢 [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 mais alta é aceitável?

Escalabilidade

• 🟡 [P1]Usuários simultâneos & solicitações: Quantos usuários simultâneos ou solicitações o sistema deve suportar?
  • Nota: A escalabilidade é frequentemente 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, picos de carga ou picos de uso baseados no tempo?

Restrições de custos

• 🟢 [P0] Limitações de custo de inferência: Quais são as restrições de custo ou 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 melhorado ao longo do tempo.

• 🟢 [P0] KPIs de negócios: Qual objetivo de negócios ou KPI o aplicativo deve impactar? Defina seus valores de linha de base e metas.
• 🟢 [P0] Feedback das partes interessadas: Quem fornecerá feedback inicial e contínuo sobre o desempenho e os resultados da aplicação? Identifique grupos de usuários específicos ou especialistas em domínio.
• 🟢 [P0] Medir a qualidade: Que métricas (por exemplo, precisão, relevância, segurança, pontuações humanas) serão utilizadas para avaliar a qualidade dos resultados gerados?
  • Como essas métricas serão calculadas durante o desenvolvimento (por exemplo, em relação a dados sintéticos, conjuntos de dados com curadoria manual)?
  • Como a qualidade será medida na produção (por exemplo, registrando e analisando respostas a consultas reais de usuários)?
  • Qual é a sua tolerância geral ao erro? (Por exemplo, aceite uma certa percentagem de pequenas imprecisões factuais ou exija cerca de 100% correção para casos de uso críticos.)
  • O objetivo é construir um conjunto de avaliação a partir de consultas reais dos usuários, 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] Feedback loops: Como o feedback do usuário deve ser coletado (por exemplo, polegares para cima/para baixo, formulários de pesquisa) e usado para impulsionar melhorias iterativas?
  • Planeie a frequência com que o feedback será revisto e incorporado.

Segurança

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

• 🟢 [P0] Sensibilidade dos dados: Existem elementos de dados sensíveis ou confidenciais que exijam um tratamento especial?
• 🟡 [P1] Controlos de acesso: Precisa de implementar controlos de acesso para restringir determinados dados ou funcionalidades?
• 🟡 [P1] Avaliação & mitigação de ameaças: O seu aplicativo precisará se proteger contra ameaças comuns de IA generativa, como injeção de comandos ou entradas de usuário mal-intencionadas?

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?
  • Identifique os pontos de integração (por exemplo, Slack, CRM, ferramentas de BI) e os 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 controlar o controle de versão do aplicativo? Este artigo aborda como o ciclo de vida de ponta a ponta pode ser tratado em Databricks usando MLflow, Unity Catalog, Agent Framework, Agent Evaluatione Model Serving.
• 🟡 [P1] Monitoramento da produção & observabilidade: Como você monitorará o aplicativo quando ele estiver em produção?
  • Registo de rastreamentos &: captura rastreamentos completos de execução.
  • Métricas de qualidade: avalie continuamente as principais métricas (como correção, latência, relevância) no tráfego ao vivo.
  • Painéis &: Configure alertas para problemas críticos.
  • Ciclo de feedback: incorpore o feedback do usuário na produção (polegares para cima ou para baixo) para detetar problemas antecipadamente e impulsionar melhorias iterativas.

Exemplo

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

Área	Considerações	Requerimentos
Experiência do utilizador	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 com o Slack. Exemplos de consultas: "Como reduzir o tempo de inicialização do cluster?" "Que tipo de plano de apoio tenho?" Respostas técnicas claras com trechos de código e links para documentação relevante, quando apropriado. Forneça sugestões contextuais e escale para dar suporte aos engenheiros quando necessário.
Lógica do agente	Compreensão e classificação de consultas. Planeamento e tomada de decisão em várias etapas. Seleção e execução autónoma de ferramentas. Gerenciamento de estado e contexto entre interações. Tratamento de erros e mecanismos de fallback.	Planeamento baseado em LLM com medidas de contingência determinísticas. Integre com um conjunto de ferramentas predefinidas (como recuperação de documentos ou ferramenta de recuperação do Salesforce). Mantenha o estado da conversação para interações coerentes em várias voltas e recuperação robusta de erros.
Dados	Número e tipo de fontes de dados. Formato e localização dos dados. Tamanho dos dados e frequência de atualização. Qualidade e consistência dos dados.	Quatro fontes de dados. Documentação da empresa (HTML, PDF). Tickets de suporte resolvidos (JSON). Publicações no fórum da comunidade (tabela Delta). Conector Salesforce. Dados armazenados no Catálogo Unity e atualizados semanalmente. Tamanho total dos dados: 5GB. Estrutura de dados consistente e qualidade mantida por documentos dedicados e equipes de suporte.
Desempenho	Latência máxima aceitável. Restrições de custos. Uso e simultaneidade esperados.	Requisito de latência máxima. Restrições de custos. Pico de carga esperado.
Avaliação	Disponibilidade do conjunto de dados de avaliação. Métricas de qualidade. Recolha de feedback dos utilizadores.	Especialistas no assunto de cada área de produto ajudam a revisar os resultados e ajustar respostas incorretas para criar o conjunto de dados de avaliação. KPIs de negócios. Aumento na taxa de resolução de pedidos de suporte. Diminuição do tempo gasto pelo utilizador por ticket de suporte. Métricas de qualidade. Correção e relevância da resposta julgadas por LLM. O LLM avalia a precisão da recuperação. Voto favorável ou negativo do usuário. Recolha de feedback. O Slack será configurado para permitir que se dê um 'gosto' ou 'não gosto'.
Segurança	Tratamento de dados sensíveis. Requisitos de controlo de acesso.	Nenhum dado confidencial do cliente deve estar na fonte de recuperação. Autenticação do usuário através do SSO da Comunidade Databricks.
Implantação	Integração com sistemas existentes. Implantação e versionamento.	Integração com sistema de tickets de suporte. Agente implantado como um ponto de extremidade de serviço do Modelo Databricks.

Desenho da solução

Fontes de dados & ferramentas

Ao projetar um aplicativo de IA de geração, é importante identificar e mapear as várias fontes de dados e ferramentas necessárias para impulsionar 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 normalmente residem em formatos tabulares bem definidos (por exemplo, uma tabela Delta ou um 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 agente de IA de extração estruturada para obter recomendações sobre como adicionar dados estruturados à sua aplicação de IA gerativa.

Dados não estruturados

Os dados não estruturados incluem documentos brutos, PDFs, e-mails, 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, fragmentação e incorporação, para serem efetivamente consultados e usados em um aplicativo de IA de geração. Consulte Ferramentas de agente de IA de recuperação não estruturada para obter recomendações sobre como adicionar dados estruturados ao seu aplicativo de IA de geração.

APIs externas & 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 a invocação de ferramentas ou a interação com APIs externas, recomendamos o seguinte:

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

Exemplo:

Um aplicativo de análise interno recupera dados de mercado em tempo real de uma API financeira externa. A aplicação utiliza:

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

Abordagem de execução

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

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

Prós:

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

Contras:

• Abstração adicionada: As estruturas de código aberto geralmente introduzem camadas de abstração que podem ser desnecessárias para o seu caso de uso específico.
• Dependência de atualizações: Você pode depender dos mantenedores da estrutura para correções de bugs e atualizações de recursos, o que pode diminuir sua capacidade de se adaptar rapidamente a 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

Prós:

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

Desvantagens:

• Maior esforço de desenvolvimento: Construir a partir do zero pode exigir mais tempo e experiência para implementar recursos que, de outra forma, uma estrutura dedicada poderia fornecer.
• Reinventar a roda: Você pode precisar desenvolver funcionalidades comuns (como encadeamento de ferramentas ou gerenciamento de prompt) por conta própria.
• Responsabilidade pela manutenção: Todas as atualizações e correções de bugs tornam-se sua responsabilidade, o que pode ser um desafio para sistemas complexos.

Em última análise, sua decisão deve ser guiada pela complexidade do seu projeto, necessidades de desempenho e o nível de controle que você precisa. Nenhuma das abordagens é inerentemente superior; Cada um oferece vantagens distintas, dependendo das suas preferências de desenvolvimento e prioridades estratégicas.

1. Construir

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

O processo de compilação segue estas etapas principais:

um. Preparar dados & ferramentas: Garantir que os dados necessários estejam acessíveis, analisados e prontos para recuperação. Implemente ou registre as funções e conexões do Catálogo Unity (por exemplo, APIs de recuperação ou chamadas de API externas) de que seu agente precisará. b. Agente de construção: Orquestre a lógica central, começando com uma abordagem POC simples. c. Verificação de qualidade: Valide funcionalidades essenciais antes de expor o aplicativo a mais usuários. d. Implantar agente de pré-produção: Disponibilizar o POC para testar usuários e especialistas no assunto para feedback inicial. e. Coletar comentários dos usuários: Use o uso do mundo real para identificar áreas de melhoria, dados ou ferramentas adicionais necessários e refinamentos potenciais para a próxima iteração.

um. Preparar dados de ferramentas &

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

Dados

1. Identificar um subconjunto representativo de dados
   • Para dados estruturados, selecione as principais tabelas ou colunas mais relevantes para o seu cenário inicial.
   • Para dados não estruturados, priorize a indexação apenas de um subconjunto de documentos representativos. Utilize um fluxo de trabalho básico de fragmentação/incorporação com Mosaic AI Vector Search para que o 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 credenciais com segurança usando um Unity Catalog Connection.
3. Validar cobertura básica
   • Confirme se o(s) subconjunto(s) de dados escolhido(s) aborda(m) adequadamente as consultas do usuário que você planeja testar.
   • Salve quaisquer fontes de dados adicionais ou transformações complexas para iterações futuras. Seu objetivo atual deve ser provar a viabilidade básica e coletar feedback.

Ferramentas

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

Ferramentas de recuperação de dados

• Consultas de dados estruturadas restritas: Se as consultas forem fixas, envolva-as em uma função SQL do Unity Catalog ou em umUDF do Python . Isso mantém a lógica centralizada e detetável.
• Consultas de dados estruturadas abertas: Se as consultas forem mais abertas, considere configurar um espaço Genie para lidar com consultas text-to-SQL.
• Funções auxiliares de dados não estruturados: Para dados não estruturados armazenados no Mosaic AI Vetor Search, criar uma ferramenta de recuperação de dados não estruturados que o agente pode chamar para buscar partes de texto relevantes.

ferramentas para chamadas de API

• Chamadas de API externas:chamadas de API podem ser invocadas diretamente usando o método http_request do SDK do Databricks.
• Wrappers opcionais: Se você precisar implementar lógica de pré ou pós-processamento (como normalização de dados ou tratamento de erros), envolva a chamada de API em uma função 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 de API. Você pode adicionar mais à medida que você repete o processo.
• Validar interativamente: Teste cada ferramenta de forma independente (por exemplo, em um notebook) antes de incorporá-la ao sistema do agente.

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

b. Agente de compilação

Depois que seus dados e ferramentas estiverem instalados, você poderá criar o agente que responde às solicitações de entrada, como consultas de usuários. Para criar um agente protótipo inicial, use Python ou AI playground. Siga estes passos:

1. Comece de forma simples
   • Escolha um padrão de design básico: Para um POC, comece com uma cadeia básica (como uma sequência fixa de etapas) ou um único agente chamador de ferramentas (onde o LLM pode chamar dinamicamente uma ou duas ferramentas essenciais).
     • Se o seu cenário estiver alinhado com um dos notebooks de exemplo fornecidos na documentação do Databricks, adapte esse código como uma base.
   • Prompt mínimo: Resista ao impulso de fazer engenharia excessiva de prompts neste momento. Mantenha as instruções sucintas e diretamente relevantes para as 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 um agente chamador de ferramentas, você fornece um esquema para que o LLM saiba como invocar a função.
     • Valide se as ferramentas isoladas estão funcionando conforme o esperado, antes de incorporá-las ao sistema do agente e testar de ponta a ponta.
   • Guardrails: Se o seu agente puder modificar sistemas externos ou executar código, assegure-se de ter verificações de segurança básicas e limitações (como limitar o número de chamadas efetuadas ou restringir determinadas ações). Implemente-os numa função do Unity Catalog .
3. Rastreie e registre o agente com o MLflow
   • Rastreie cada etapa: Use o rastreamento do MLflow para capturar entradas, saídas e tempo decorrido de cada etapa, a fim de depurar problemas e medir o desempenho.
   • Registrar o agente: Utilizar o MLflow Tracking para registrar o código e a configuração do agente.

Nesta fase, perfeição não é o objetivo. Você quer um agente simples e funcional que possa ser implantado para obter feedback antecipado de usuários de teste e PMEs. O próximo passo é executar uma verificação de qualidade rápida antes de disponibilizá-lo em um ambiente de pré-produção.

c. Controlo de qualidade

Antes de expor o agente a uma audiência de pré-produção mais vasta, faça um teste de qualidade offline "suficientemente bom" para identificar problemas principais antes de implementá-lo numa endpoint. Neste estágio, normalmente não terás um conjunto de dados de avaliação grande e robusto, mas ainda podes efetuar uma verificação rápida para garantir que o agente se comporte conforme o esperado em algumas consultas de amostra.

1. Teste interativamente em um notebook
   • Teste manual: Contacte manualmente o seu agente com pedidos representativos. Preste atenção se ele recupera os dados certos, chama as ferramentas corretamente e segue o formato desejado.
   • Inspecionar rastreamentos MLflow: Se tiveres ativado o Rastreamento MLflow, revê a telemetria passo a passo. Confirme se o agente escolhe a(s) ferramenta(s) apropriada(s), 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 eliminar etapas ou simplificar a lógica antes de ir mais longe.
2. Vibe verificar
   • Isso pode ser feito em um notebook ou em AI Playground.
   • Coerência & exatidão: A resposta do agente é lógica para as consultas que testaste? Há imprecisões gritantes ou detalhes em falta?
   • Casos extremos: Se tentaste algumas consultas fora do comum, o agente ainda respondeu logicamente ou, pelo menos, falhou com elegância (por exemplo, recusando-se educadamente a responder em vez de produzir resultados absurdos)?
   • Adesão imediata: Se você forneceu instruções de alto nível, como tom desejado ou formatação, o agente está seguindo isso?
3. Avaliar "qualidade suficientemente boa"
   • Se você estiver limitado em consultas de teste neste momento, considere gerar dados sintéticos. Consulte Criar um conjunto de avaliação.
   • Resolva os principais problemas: Se você descobrir falhas importantes (por exemplo, o agente repetidamente chama ferramentas inválidas ou gera bobagens), 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 uma barra básica de usabilidade e correção para um pequeno conjunto de consultas, você poderá prosseguir. Caso contrário, refine os prompts, corrija problemas de ferramentas ou dados e teste novamente.
4. Planeie os próximos passos
   • Acompanhe as melhorias: Documente quaisquer deficiências que decida adiar. Depois de coletar feedback do mundo real na pré-produção, você pode revisitá-los.

Se tudo parecer viável para uma distribuição limitada, você estará pronto para implantar o agente na pré-produção. Um processo de avaliação minucioso acontecerá em fases posteriores, especialmente depois de ter mais dados reais, feedback das PME 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 o agente de pré-produção

Depois que o agente atingir um limiar de qualidade básica, a próxima etapa é hospedá-lo num ambiente de pré-produção para que você possa entender como os usuários interagem com a aplicação e coletar seu feedback para guiar o desenvolvimento. Este ambiente pode ser o seu ambiente de desenvolvimento durante a fase POC. O principal requisito é que o ambiente seja acessível para selecionar testadores internos ou especialistas em domínio.

1. Implantar o agente
   • Agente de log e registro: Primeiro, registrar o agente como um modelo MLflow e registrá-lo no Unity Catalog.
   • Implantar usando o Agent Framework: Use o Agent Framework para obter o agente registado e implantá-lo como um endpoint de serviço de modelo.
2. Tabelas de inferência
   • O Agent Framework armazena automaticamente solicitações, respostas e rastreamentos, juntamente com metadados, em uma tabela de inferência no Unity Catalog para cada ponto de extremidade de serviço.
3. Proteja e configure
   • Controle de acesso:Restrinja o acesso ao endpoint ao seu grupo de teste (PMEs, usuários avançados). Isso garante o uso controlado e evita a exposição inesperada de dados.
   • de 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 feedback sobre consultas reais. Uma das maneiras de interagir rapidamente com o agente é no AI Playground , onde o utilizador pode selecionar o endpoint de serviço de modelo recém-criado e consultar o agente.

e. Coletar comentários dos usuários

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

1. Utilizar a aplicação de revisão

   • Quando você implanta seu agente com o Agent Framework, um simples de aplicativo de revisão de no estilo de bate-papo é criado. Ele fornece uma interface amigável onde os testadores podem fazer perguntas e classificar imediatamente as respostas do agente.
   • Todas as solicitações, respostas e comentários dos utilizadores (gostos/não gostos, comentários escritos) são automaticamente registados em uma tabela de inferência , tornando mais fácil a análise posterior.

2. Use a interface de monitoramento para inspecionar os logs

   • Acompanhe os votos positivos/negativos ou comentários na interface do usuário de monitorização para ver quais respostas os testadores avaliaram como particularmente úteis (ou inúteis).

3. Envolva especialistas em domínio

   • Incentivar as PME a depararem-se com cenários típicos e invulgares. O conhecimento do domínio ajuda a revelar erros sutis, como interpretações incorretas de políticas ou dados ausentes.
   • Mantenha uma lista de problemas pendentes, desde pequenos ajustes em prompt até grandes refatorações na pipeline de dados. Decida quais correções priorizar antes de seguir em frente.

4. Curar novos dados de avaliação

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

5. Iterar com base no feedback recebido

   • Aplique correções rápidas, como pequenas mudanças de prompt ou novos guarda-corpos, para resolver problemas imediatos.
   • Para questões mais complexas, como a necessidade de lógica avançada em várias etapas ou novas fontes de dados, reúna evidências suficientes antes de investir em grandes mudanças arquitetônicas.

Ao aproveitar os comentários do Aplicativo de revisão, os logs da tabela de inferência e as perceções das PMEs, essa fase de pré-produção ajuda a preencher as principais lacunas e refinar seu agente iterativamente. As interações do mundo real reunidas nesta etapa criam a base para a construção de um conjunto de avaliação estruturado, permitindo que você faça a transição de melhorias ad hoc para uma abordagem mais sistemática à medição de qualidade. Depois que os problemas recorrentes forem resolvidos e o desempenho estabilizar, você estará bem preparado para uma implantação de produção com uma avaliação robusta.

2. Avaliar & 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 de "avaliar e iterar" transforma o feedback bruto e os logs em um conjunto de avaliação estruturado, permitindo que você teste repetidamente as melhorias e garanta que seu aplicativo atenda aos padrões exigidos de precisão, relevância e segurança.

Esta fase inclui as seguintes etapas:

• Reúna consultas reais a partir de logs: Selecione interações de alto valor ou problemáticas de suas tabelas de inferência e transforme-as em casos de teste.
• Adicione rótulos de especialistas: 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, fundamentação e outras dimensões de qualidade de forma mais objetiva.
• Tire partido da Avaliação do Agente: Use juízes LLM integrados ou verificações personalizadas para quantificar a qualidade da aplicação.
• Iterar: Melhore a qualidade refinando a lógica, os pipelines de dados ou os prompts do seu assistente. Execute novamente a avaliação para confirmar se você resolveu os principais problemas.

Observe que esses recursos funcionam mesmo se a sua aplicação de IA generativa for executada fora da Databricks. Ao instrumentar seu código com o MLflow Tracing, você pode capturar rastreamentos de qualquer ambiente e unificá-los na Databricks Data Intelligence Platform para avaliação e monitoramento consistentes. À medida que você continua a incorporar novas consultas, feedbacks e insights de PMEs, 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 os objetivos de negócios.

Avalie o agente

Depois que seu agente estiver sendo executado em um ambiente de pré-produção, a próxima etapa é medir sistematicamente seu desempenho além das verificações de vibração ad-hoc. Mosaic AI Agent Evaluation permite criar conjuntos de avaliação, executar verificações de qualidade com juízes LLM integrados ou personalizados e iterar rapidamente em áreas problemáticas.

Avaliações offline e online

Ao avaliar aplicações de IA gen, existem duas abordagens principais: avaliação offline e avaliação online. Esta fase do ciclo de desenvolvimento centra-se na avaliação offline, que se refere à avaliação sistemática fora das interações ao vivo do utilizador. A avaliação on-line é abordada mais tarde quando se discute o monitoramento de seu agente na produção.

As equipes geralmente dependem muito de "testes de vibração" por muito tempo no fluxo de trabalho do desenvolvedor, tentando informalmente um punhado de consultas e julgando subjetivamente se as respostas parecem razoáveis. Embora isso forneça um ponto de partida, falta o rigor e a cobertura necessários para construir aplicações de qualidade de produção.

Em contraste, um processo de avaliação offline adequado faz o seguinte:

• Estabelece uma referência de qualidade antes de uma implantação mais ampla, criando métricas claras visando melhorias.
• Identifica pontos fracos específicos que requerem atenção, indo além da limitação de testar apenas casos de uso esperados.
• Deteta 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 extremos e modos de falha potenciais antes que os usuários o façam.
• Reduz o risco de implantar um agente com baixo desempenho na produção.

Investir tempo na avaliação off-line paga dividendos significativos a longo prazo, ajudando-o a fornecer respostas consistentes de alta qualidade.

Criar um conjunto de avaliação

Um conjunto de avaliação serve como base para medir o desempenho da sua aplicação 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 sua referência de qualidade e conjunto de dados de teste de regressão.

Pode construir um conjunto de avaliação através de várias abordagens complementares:

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

   Os dados de avaliação mais valiosos vêm diretamente do uso real. Sua implementação em pré-produção gerou logs de tabelas de inferência contendo solicitações, respostas dos agentes, chamadas de funções e contexto recuperado.

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

   • Cobertura do mundo real: Comportamentos imprevisíveis do usuário que você pode não ter previsto estão incluídos.
   • Focado no problema: Você pode filtrar especificamente para feedback negativo ou respostas lentas.
   • Distribuição representativa: A frequência real de diferentes tipos de consulta é capturada.

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

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

   • Devolve respostas coerentes e precisas.
   • Responde no formato certo.
   • 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 vai querer:

   • Peça às PMEs ou especialistas em domínios que analisem e eliminem quaisquer perguntas irrelevantes ou repetitivas.
   • Substitua-o ou complemente-o mais tarde com logs de uso em situações reais.

3. Curar consultas manualmente

   Se preferir não confiar em 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ções a partir delas. Consultas representativas podem vir de entrevistas com utilizadores ou de sessões de concepção de ideias por desenvolvedores. Mesmo uma lista curta e selecionada pode expor falhas gritantes nas respostas do seu agente.

Estas abordagens não se excluem mutuamente, mas são 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 selecionados manualmente para testar a funcionalidade principal.
• Opcionalmente, adicione dados sintéticos para ampliar a cobertura antes de ter dados reais do usuário.
• Incorpore gradualmente logs do mundo real à medida que eles se tornam disponíveis.
• Atualize continuamente com novos exemplos que reflitam padrões de uso em mudança.

Práticas recomendadas para consultas de avaliação

Ao elaborar seu conjunto de avaliação, inclua deliberadamente diversos tipos de consulta, como os seguintes:

• 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 imediata (como tentativas de revelar o prompt do sistema).
• Consultas complexas que exigem várias etapas de raciocínio ou chamadas de ferramentas.
• Casos extremos com informações mínimas ou ambíguas (como erros ortográficos ou consultas vagas).
• Exemplos de diferentes níveis de habilidade de utilizadores e contextos.
• Consultas que testam possíveis enviesamentos nas respostas (como "comparar Empresa A vs Empresa B").

Lembre-se de que o seu conjunto de avaliação deve crescer e evoluir juntamente com a sua aplicação. À 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 os padrões em relação aos quais as respostas do agente são medidas, permitindo uma avaliação objetiva em múltiplas dimensões da qualidade.

Factos de verdade fundamentada ou respostas de referência

Ao avaliar a exatidão factual, existem duas abordagens principais: factos esperados ou respostas de referência. Cada um serve um propósito diferente na sua estratégia de avaliação.

Use fatos esperados (recomendado)

A abordagem expected_facts envolve listar os principais factos que devem aparecer numa resposta correta. Para obter um exemplo, consulte exemplo de conjunto de avaliação com request, response, guidelinese expected_facts.

Esta abordagem oferece vantagens significativas:

• Permite flexibilidade na forma como os factos são expressos na resposta.
• Torna mais fácil para as PME fornecer a verdade básica.
• Acomoda diferentes estilos de resposta, garantindo a presença das informações essenciais.
• Permite uma avaliação mais confiável entre versões de modelo ou configurações de parâmetros.

O juiz de correção interno verifica se a resposta do agente incorpora esses fatos essenciais, independentemente do fraseado, da ordem ou do conteúdo adicional.

Use a resposta esperada (alternativa)

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

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

Databricks geralmente recomenda o uso de expected_facts sobre expected_response porque fornece mais flexibilidade e, ao mesmo tempo, garante precisão.

Diretrizes para conformidade com estilo, tom ou política

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

Diretrizes apenas

Se a sua principal preocupação é impor requisitos de estilo ou política em vez de precisão factual, você pode fornecer diretrizes sem 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 árbitro LLM interpreta essas instruções em linguagem natural e avalia se a resposta está conforme elas. Isso funciona particularmente bem para dimensões subjetivas de qualidade, como tom, formatação e adesão às políticas organizacionais.

Combinando dados reais e diretrizes

Para uma avaliação abrangente, você pode combinar verificações de precisão factual com diretrizes de estilo. Veja o conjunto de amostra de avaliação com request, response, guidelinese 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 já capturou pares de pedido-resposta do desenvolvimento ou de testes, pode avaliá-los diretamente sem chamar o seu agente. Isto é útil para:

• Analisar padrões existentes no comportamento do seu agente.
• Análise comparativa de desempenho em relação às versões anteriores.
• Poupar tempo e custos ao não regenerar respostas.
• Avaliação de um agente atendido fora do Databricks.

Para obter detalhes sobre como fornecer as colunas relevantes no seu DataFrame de avaliação, consulte Exemplo: Como passar os resultados anteriormente gerados para o Agent Evaluation. O Mosaic AI Agent Evaluation usa esses valores pré-capturados em vez de chamar seu agente novamente, enquanto ainda aplica as mesmas verificações de qualidade e métricas.

Melhores práticas para os critérios de avaliação

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

1. Ser específico e objetivo: Definir critérios claros e mensuráveis que diferentes avaliadores interpretariam de forma semelhante.
   • Considere adicionar métricas personalizadas para medir os critérios de qualidade que lhe interessam.
2. Concentre-se no valor para o usuário: Priorize critérios que se alinhem com o que é mais importante para seus usuários.
3. Comece simples: Comece com um conjunto básico de critérios e expanda à medida que sua compreensão das necessidades de qualidade cresce.
4. Equilíbrio na cobertura: Inclua critérios que abordem diferentes aspetos da qualidade (por exemplo, exatidão factual, estilo e segurança).
5. Itere com base no feedback: Refine seus critérios com base no feedback do usuário e nos requisitos em evolução.

Consulte Melhores práticas para desenvolver um conjunto de avaliação para obter mais informações sobre a criação de conjuntos de dados de avaliação de alta qualidade.

Executar avaliações

Agora que você preparou um conjunto de avaliações com consultas e critérios, você pode executar uma avaliação usando mlflow.evaluate(). Esta função trata de todo o processo de avaliação, desde invocar o 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 é desencadeada:

1. Para cada linha do conjunto de avaliação, mlflow.evaluate() faz o seguinte:
   • Ligue para o seu agente com a consulta (se ainda não tiver fornecido uma resposta).
   • Aplica juízes LLM integrados para avaliar as dimensões da qualidade.
   • Calcula métricas operacionais, como uso e latência de tokens.
   • Regista os fundamentos detalhados de cada avaliação.
2. Os resultados são automaticamente registrados 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 avaliação

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

• Selecione quais juízes internos executar.
• Defina diretrizes globais que se apliquem a todos os exemplos.
• Configure limites para juízes.
• Forneça poucos exemplos para orientar as avaliações dos juízes.

Para obter detalhes e exemplos, consulte Exemplos.

Avalie agentes fora do Databricks

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

Quais juízes são designados

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

Analise os resultados da avaliação

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

Navegar pelos resultados da avaliação

Ao abrir a interface do usuário do MLflow depois de executar mlflow.evaluate(), você encontrará várias exibições interconectadas. Para obter informações sobre como navegar nesses resultados na interface do usuário MLflow, consulte Revisão de saída usando a interface do usuário MLflow.

Para obter orientações sobre como interpretar padrões de falha, consulte b. Melhorar o agente e as ferramentas.

A IA personalizada avalia as métricas &

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

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 subjetivas ou matizadas da qualidade que se beneficiam do julgamento semelhante ao humano, tais como:

• Conformidade específica do domínio (legal, médico, financeiro).
• Voz da marca e estilo de comunicação.
• Sensibilidade e adequação cultural.
• Qualidade de raciocínio complexo.
• Convenções de escrita especializadas.

A saída do juiz aparece na interface do usuário do MLflow ao lado de juízes internos, com os mesmos fundamentos detalhados explicando as avaliações.

Métricas personalizadas

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

As métricas personalizadas são ideais para:

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

b. Melhorar o agente e as ferramentas

Depois de executar a avaliação e identificar os problemas de qualidade, o próximo passo é abordar 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 análises dos especialistas do LLM, baseadas nos resultados da sua avaliação, indicam tipos específicos de falhas no seu sistema de agentes. Esta seção explora esses padrões de falha comuns e suas soluções. Para obter informações sobre como interpretar saídas de juízes LLM, consulte saídas de juízes de IA.

Práticas recomendadas de iteração de qualidade

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

1. Versione as suas alterações
   • Registre cada iteração significativa usando o MLflow Tracking.
   • Salve prompts, configurações e parâmetros-chave em um arquivo de configuração central. Certifique-se de que isso esteja registrado com o agente.
   • Para cada novo agente implantado, mantenha um changelog no seu repositório detalhando o que mudou e por que.
2. Documentar o que funcionou e o que não funcionou
   • Documente abordagens bem-sucedidas e malsucedidas.
   • Observe o impacto específico de cada alteração nas métricas. Link de volta para a execução do MLflow de Avaliação do Agente.
3. Alinhar-se com as partes interessadas
   • Use o aplicativo de avaliações para validar melhorias com PMEs.
     • Comunique as alterações usando as instruções do revisor .
   • Para comparação lado a lado de diferentes versões de um agente, pense em criar múltiplos pontos finais de agente e usar o modelo no Playground de IA . Isso permite que os usuários enviem a mesma solicitação para pontos de extremidade separados e examinem a resposta e os rastreamentos lado a lado.

3. Produção

Depois de avaliar iterativamente e melhorar seu aplicativo, você atingiu um nível de qualidade que atende às suas necessidades e está pronto para uso mais amplo. A fase de produção envolve a implantação do agente refinado no ambiente de produção e a implementação do monitoramento contínuo para manter a qualidade ao longo do tempo.

A fase de produção inclui:

• Implantar agente na produção: Configure um ponto de extremidade pronto para produção com configurações apropriadas de segurança, dimensionamento e autenticação.
• Monitorar o agente na produção: Estabeleça avaliação contínua da qualidade, rastreamento de desempenho e alertas para garantir que seu agente mantenha alta qualidade e confiabilidade no uso no mundo real.

Isso cria um ciclo de feedback contínuo onde os insights de monitoramento geram 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 de negócios em evolução durante todo o seu ciclo de vida.

um. Implantar o agente na produção

Depois de concluir a avaliação completa e o aperfeiçoamento iterativo, você estará pronto para implantar seu agente em um ambiente de produção. [Estrutura do Agente de IA Mosaico](/generative-ai/agent-framework/build-gen AI-apps.md#agent-framework) simplifica este processo ao lidar com muitas questões de implementação automaticamente.

Processo de implantação

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

1. Registre e registre seu agente como um modelo MLflow no Unity Catalog.
2. Implante o agente usando o Agent Framework.
3. Configure a autenticação para quaisquer recursos dependentes seu agente precise acessar.
4. Teste a implantação para verificar a funcionalidade no ambiente de produção.
   • Depois de o endpoint do modelo estar pronto, poderás interagir com o agente no AI Playground, onde poderás testar e verificar a funcionalidade.

Para obter etapas detalhadas de implementação, consulte Implementar um agente para aplicação de IA generativa.

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

Ao passar para a produção, tenha em mente as seguintes considerações principais:

Desempenho e dimensionamento

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

Segurança e governação

• Garanta controles de acesso adequados no nível do Catálogo Unity para todos os componentes do agente.
• Utilize a passagem de autenticação incorporada para os recursos do Databricks sempre que possível.
• Configure o gerenciamento de credenciais apropriado para APIs ou fontes de dados externas.

Abordagem de integração

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

Recolha de feedback

• Aproveite o aplicativo de revisão para obter feedback das partes interessadas durante a implantação inicial.
• Projete mecanismos para coletar feedback do usuário diretamente na interface do aplicativo.
  • O ponto de extremidade de feedback criado para coletar feedback do Review App também pode ser utilizado por aplicações externas para fornecer feedback sobre o seu agente. Veja Dar feedback sobre um agente implementado.
• Garanta que os dados de feedback fluam para o seu processo de avaliação e melhoria.

b. Agente de monitorização em produção

Depois que seu agente é implantado na produção, é essencial monitorar continuamente seu desempenho, qualidade e padrões de uso. Ao contrário do software tradicional, onde a funcionalidade é determinística, os aplicativos de IA de geração podem exibir desvio de qualidade ou comportamentos inesperados à medida que encontram entradas do mundo real. O monitoramento eficaz permite detetar problemas precocemente, entender os padrões de uso e melhorar continuamente a qualidade do seu aplicativo.

Configurar o monitoramento do agente

O Mosaic AI fornece recursos integrados de monitoramento de que permitem acompanhar o desempenho do seu agente sem criar uma infraestrutura de monitoramento personalizada:

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

Principais dimensões de monitorização

De um modo geral, um controlo eficaz deve abranger três dimensões críticas:

1. Métricas operacionais

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

2. Métricas de qualidade

   • Relevância para as consultas dos utilizadores.
   • Fundamentação no contexto recuperado.
   • Segurança e adesão às diretrizes.
   • Taxa de aprovação de qualidade geral.

3. Comentários dos utilizadores

   • Feedback explícito (gosto/não gosto).
   • Sinais implícitos (perguntas de acompanhamento, conversas abandonadas).
   • Problemas reportados aos canais de suporte.

Usar a interface do usuário de monitoramento

Interface de utilizador de monitorização fornece perspetivas visualizadas nessas dimensões por meio de duas abas.

• aba Gráficos: Veja as tendências no volume de solicitações, métricas de qualidade, latência e erros ao longo do tempo.
• aba Logs: Examine solicitações individuais e respostas, incluindo os resultados da avaliação.

Os recursos de filtragem permitem que os usuários pesquisem consultas específicas ou filtrem por resultado da avaliação. Para obter mais informações, consulte a interface de monitorização.

Criar painéis e alertas

Para uma monitorização abrangente:

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

Ciclo de melhoria contínua

O monitoramento é mais valioso quando retroalimenta seu processo de melhoria:

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

Essa abordagem iterativa e de ciclo fechado ajuda a garantir que seu agente continue a melhorar com base em padrões de uso do mundo real, mantendo alta qualidade enquanto se adapta às mudanças nos requisitos e comportamentos do usuário. Com o Monitoramento de agentes, você ganha visibilidade sobre o desempenho do seu agente na produção, permitindo que você resolva problemas de forma proativa e otimize a qualidade e o desempenho.