Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Pipeline de ponta a ponta: traces, juízes, conjuntos de dados, avaliações

Aula 16 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. O fluxo de trabalho de observabilidade de ponta a ponta
  2. Implementação em Python
  3. Resumo do curso
  4. Próximos passos recomendados
  5. Pontos-chave
  6. Teste os seus conhecimentos

Lição reescrita em 2 de novembro de 2026 com base na documentação de Observabilidade da Mistral e no SDK mistralai 3.7.0: o pipeline agora encadeia traces, juízes, conjuntos de dados e avaliações offline. A funcionalidade “Campaigns” e os métodos chat_completion_events.search, campaigns.* e import_from_explorer da versão anterior deixaram de existir. Fontes: Explorar traces · Avaliações offline.

O fluxo de trabalho de observabilidade de ponta a ponta

Já dominou cada componente da pilha de observabilidade da Mistral. Esta lição final reúne as peças num pipeline completo que pode reproduzir e adaptar ao seu contexto de produção.

1

Trace e explore

Ative a telemetria e, em seguida, filtre os traces dos últimos 7 dias no Explorer: erros, lentidão, respostas suspeitas. Anote a expressão de pesquisa.

2

Julgue

Formalize o critério de qualidade em questão num juiz (classificação ou regressão), validado em 10 a 20 casos conhecidos.

3

Construa um conjunto de dados

Transforme os spans problemáticos em registos, com a saída esperada corrigida manualmente.

4

Avalie

Meça a versão atual e, em seguida, cada variante face a este conjunto de dados, com objetivos de APROVADO/REPROVADO.

5

Itere

Implemente a variante vencedora, mantenha o conjunto de dados como uma salvaguarda de não regressão e repita.

Implementação em Python

O script abaixo automatiza os passos 1, 3 e 4; o juiz para o passo 2 é criado uma única vez, como na Lição 13. Coexistem dois clientes: o cliente do SDK mistralai para traces e conjuntos de dados, e o cliente mistralai-evaluations para avaliação.

import asyncio
import os
from datetime import datetime, timedelta, timezone

from mistralai.client import Mistral
from mistralai.evaluations import Dataset, Evaluation, Evaluator, Goal, Project, System
from mistralai.evaluations import Mistral as MistralEvaluations

key = os.environ["MISTRAL_API_KEY"]
api = Mistral(api_key=key)
evaluations = MistralEvaluations(api_key=key)

# 1. Identificar traces falhados da semana
now = datetime.now(timezone.utc)
response = api.beta.observability.traces.search(
    from_=now - timedelta(days=7),
    to=now,
    search_expression="service_name = 'agent-support' AND status_code = 'Error'",
)
for trace in response.traces.results or []:
    print(trace.trace_id, trace.root_span_name)

# 3. Adicionar casos revistos e corrigidos manualmente ao conjunto de dados
corrected_cases = [
    {"ticket": "Payment refused even though my card is valid.", "category": "billing"},
    {"ticket": "Unable to add a colleague to my workspace.", "category": "access"},
]
dataset = api.beta.observability.datasets.create(
    name="Support incidents — week 44",
    description="Cases drawn from failed traces, expected output corrected",
)
for case in corrected_cases:
    api.beta.observability.datasets.create_record(dataset_id=dataset.id, payload=case)


# 4. Avaliar a versão candidata (tarefa e precisão: ver Lição 14)
async def main():
    run = await evaluations.evaluation.run(
        project=Project(name="Ticket sorting"),
        evaluation=Evaluation(name="Week 44 non-regression"),
        system=System(name="medium-prompt-v2", params={
            "model": "mistral-medium-latest",
            "system_prompt": "Classify the ticket: access, billing, or bug. Reply with a single word.",
        }),
        dataset=Dataset(id=dataset.id),
        task=task,
        evaluators=[Evaluator(name="accuracy", scorer=accuracy, goal=Goal.gte(0.9))],
    )
    run.show(level="records")


asyncio.run(main())

Executado semanalmente, este script expande o conjunto de dados de não regressão com incidentes reais, e cada versão candidata deve cumprir os seus objetivos neste conjunto de dados antes da implementação.

Resumo do curso

Este curso guiou-o através de quatro domínios essenciais para a produção de IA com a Mistral:

Inferência em Lote (Lições 1-4)

Sabe como processar milhões de pedidos a um custo reduzido, utilizando o formato JSONL, loteamento de ficheiros e loteamento inline.

Saídas Previstas (Lições 5-7)

Sabe como reduzir a latência de geração ao fornecer uma previsão de saída, particularmente para código e edição de texto.

Citações e Referências (Lições 8-10)

Sabe como ancorar as respostas do seu LLM em fontes verificadas, analisar citações e construir pipelines RAG fiáveis.

Observabilidade (Lições 11-16)

Sabe como rastrear a sua aplicação com OpenTelemetry, explorar traces de produção, automatizar a avaliação de qualidade com juízes, construir conjuntos de dados e medir cada versão através de avaliações offline.

Próximos passos recomendados

A melhor forma de consolidar estas competências é aplicá-las pela ordem que mais beneficia o seu ambiente de produção. Comece por implementar um pipeline em lote num caso de uso concreto na sua organização — uma classificação mensal, um enriquecimento de catálogo — pois é o ganho mais rápido de demonstrar. De seguida, integre as Saídas Previstas sempre que as suas ferramentas editarem código ou documentos existentes: o ganho de latência é mensurável em dias. Adicione citações ao seu sistema RAG assim que os utilizadores confiarem nas suas respostas para tomar decisões. Por fim, a observabilidade começa com o envio de traces, o que é possível com uma simples chave de API; o Explorer e as avaliações offline requerem uma organização Enterprise. É o nível Enterprise que transformará as primeiras três iniciativas num ciclo de melhoria contínua, em vez de implementações pontuais.

Pontos-chave

  • O pipeline segue o ciclo: rastrear e explorar, julgar, construir um conjunto de dados, avaliar, iterar
  • Cada incidente de produção pode tornar-se num caso de teste, e cada versão candidata deve cumprir os seus objetivos
  • Automatize o ciclo com o SDK (traces.search, datasets.create_record, evaluation.run) e execute-o em intervalos regulares
  • Os quatro domínios deste curso (lote, saídas previstas, citações, observabilidade) complementam-se para uma produção de IA robusta

Teste os seus conhecimentos

Lote, latência, citações, observabilidade: os quatro pilares da produção.

1. Quando é que a Inferência em Lote é a escolha certa?

Resposta: Para grandes volumes sem restrições de tempo real: trabalhos JSONL assíncronos (ou inline até 10 000 pedidos) a custo reduzido — classificação, enriquecimento, geração em massa.

2. O que são as Saídas Previstas?

Resposta: Uma aceleração quando a resposta é largamente previsível (edição de texto existente, modelos): fornece a previsão e o modelo apenas “paga” pelas diferenças — a latência cai significativamente.

3. O que permitem as citações com Objeto de Referência?

Resposta: Ligar cada afirmação na resposta às suas fontes num RAG: respostas verificáveis, alucinações reduzidas — a confiança torna-se uma propriedade do produto.

4. O que faz no Explorer?

Resposta: Pesquisar e inspecionar traces de produção — usando uma linguagem de expressão em service_name, status_code, duration_ns ou atributos de span — para encontrar pedidos problemáticos e, em seguida, transformá-los em casos de teste: a matéria-prima para qualquer melhoria.

5. Como é que juízes, conjuntos de dados e avaliações trabalham em conjunto?

Resposta: Os juízes avaliam automaticamente (LLM-as-judge), os conjuntos de dados acumulam casos de teste retirados da produção e as avaliações offline medem cada versão face a estes conjuntos de dados com objetivos de APROVADO/REPROVADO — o ciclo trace → juiz → construir → avaliar.

O pipeline final do curso encadeia todos os quatro: produzir economicamente, responder rapidamente, fundamentar respostas, observar — produção madura num único fluxo de trabalho.