Como transformar os traces do seu agent em um modelo com fine-tuning em um único workflow

Ver no idioma original →

Autoria: LangChain · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: How to go from your agent’s traces to a fine-tuned model in one workflow · Canal: LangChain · 08:29 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Modelos de IA

Resumo

Jake, da LangChain, apresenta a versão beta pública do LangSmith fine-tuning e o SmithTune, uma CLI para transformar traces de agents em dados de treinamento e modelos ajustados. O workflow reúne seleção e revisão de trajetórias, preparação dos dados, planejamento, treinamento e avaliação. O vídeo demonstra o processo usando um coding agent, juízes de modelos e um provedor de treinamento. Ao final, os resultados podem orientar uma nova iteração ou o deploy do modelo ajustado.

Pontos-chave

• Supervised fine-tuning (SFT) ensina comportamentos desejados por meio de exemplos de referência, como escolher ferramentas, seguir workflows e se recuperar de erros.
• Trajetórias detalhadas preservam o contexto de cada ação do agent, incluindo as ferramentas disponíveis em cada turno.
• O SmithTune permite filtrar trajetórias e usar uma rubric com revisores para selecionar exemplos de treinamento.
• Os dados selecionados são enviados ao LangSmith para formar um dataset de golden trajectories.
• A etapa de preparação divide os exemplos em conjuntos de treinamento, validação e teste.
• O comando de planejamento permite revisar configurações como learning rate, batch size e epochs antes do treinamento.
• Durante o treinamento, o SmithTune seleciona o checkpoint com a menor validation loss e compara o modelo ajustado ao modelo base.
• Os resultados da avaliação ajudam a decidir se é melhor fazer deploy ou refinar os dados e as configurações para outra iteração.

Capítulos

Início	Capítulo	Resumo
00:00	SmithTune e o objetivo do fine-tuning	O vídeo apresenta o SmithTune e explica como SFT pode ensinar comportamentos úteis a agents.
01:38	Selecionar e revisar trajetórias	O processo usa traces do LangSmith, filtros e uma rubric para escolher trajetórias adequadas como exemplos.
02:41	Criar o dataset de treinamento	A demonstração usa a CLI e revisores de modelos para aprovar trajetórias e enviá-las ao LangSmith.
04:47	Preparar dados e planejar o treinamento	O dataset é preparado, dividido entre treino, validação e teste, e as configurações do job são revisadas.
06:53	Treinar, avaliar e fazer deploy	O vídeo mostra o treinamento, a comparação com o modelo base e as opções de iterar ou disponibilizar o modelo ajustado.

Citações

Transforme os traces do seu agent em um modelo com fine-tuning em um único workflow. — 00:00

O SmithTune torna esse processo contínuo em um único workflow de ponta a ponta. — 01:06

Vamos treinar com 41 exemplos, testar com cinco e reservar quatro para validação. — 05:50

Criar, preparar, planejar, treinar, avaliar e fazer deploy. — 08:29

Conceitos e entidades

• SmithTune (ferramenta): CLI apresentada no vídeo para transformar traces do LangSmith em modelos submetidos a fine-tuning.
• LangSmith (produto): Produto da LangChain usado para armazenar traces, criar datasets e comparar resultados de avaliação.
• LangChain (empresa): Empresa responsável pelo lançamento do LangSmith fine-tuning em beta público.
• Supervised fine-tuning (conceito): Método que ensina comportamentos desejados a um modelo usando exemplos de referência.
• trajectory (conceito): Representação detalhada de uma trajetória de agent, incluindo o contexto e as ferramentas disponíveis em cada turno.
• Base10 (empresa): Provedor usado na demonstração para treinar o modelo ajustado.
• Fireworks (empresa): Provedor citado como alternativa para executar o treinamento.
• Qwen3.8 27B (modelo): Modelo escolhido na demonstração como modelo-base para supervised fine-tuning.
• DeepSeek V4.1 Flash (modelo): Modelo citado como um dos juízes usados para revisar as trajetórias.
• GLM-5.3-Flash (modelo): Modelo citado como um dos juízes usados para revisar as trajetórias.

Tradução completa (pt-BR)

00:00 Passe dos traces do seu agent para um modelo fine-tuned em um único workflow. Oi, sou Jake, da LangChain, e hoje estamos lançando o fine-tuning do LangSmith em beta público com o SmithTune, uma CLI que permite fazer post-training de modelos a partir dos traces do LangSmith em um único workflow. O fine-tuning supervisionado, ou SFT, ensina ao modelo o comportamento desejado por meio de exemplos de referência. Para agents, isso pode significar escolher as ferramentas certas, seguir um workflow específico, se recuperar de erros ou saber quando pedir esclarecimentos.

00:34 Você pode usar SFT para especializar um modelo grande para sua aplicação, destilar o comportamento de um modelo de ponta em um modelo menor ou estabelecer uma política inicial para reinforcement learning. Dependendo do seu objetivo e dos dados de treinamento, isso pode melhorar a precisão nas tarefas e a confiabilidade no uso de ferramentas, ou reduzir custos e latência ensinando um comportamento mais eficiente. Chegar a esse resultado a partir dos traces do seu agent geralmente significa combinar manualmente várias etapas: selecionar bons traces, preservar as mensagens e o contexto das ferramentas,

01:06 formatar os dados de treinamento, executar o fine-tuning, avaliar se o modelo resultante realmente melhora e, então, fazer o deploy desse modelo, se você gostar dos resultados. Neste vídeo, vamos mostrar como o SmithTune torna esse processo simples em um workflow completo, de ponta a ponta. Vamos começar. Primeiro, é extremamente importante termos uma representação sólida do contexto por trás de cada ação executada pelo nosso agent. No LangSmith, isso é representado no formato de trajetória, em que podemos ver uma reconstrução detalhada do percurso do agent enquanto ele realizava uma determinada tarefa.

01:38 Queremos registrar o que os agents viram em cada turno. Por isso, é importante ter uma representação que nos permita ver tudo a que o agent teve acesso, incluindo ferramentas disponíveis para ele naquele turno. Isso é particularmente importante porque, em alguns casos, no caso de agents de longa duração, as ferramentas disponíveis podem mudar a cada turno. Por isso, precisamos de uma representação sólida disso. Felizmente, o formato de trajetória do LangSmith permite reconstruir esse contexto exatamente da maneira de que precisamos para nossos trabalhos de post-training. O SmithTune começa com o projeto de tracing do LangSmith, onde temos trajetórias de exemplo.

02:11 A partir daí, baixaremos essas trajetórias, aplicando, se quisermos, filtros para armazená-las em um diretório local. Em seguida, você e seu coding agent, que usa a CLI do SmithTune, vão definir uma rubrica específica para a tarefa, a fim de determinar o que constitui uma boa trajetória. Isso nos ajudará a manter as trajetórias que queremos usar como exemplos de referência. Essa rubrica será então enviada a um conselho de modelos com três avaliadores independentes, cada um decidindo se mantém ou descarta uma trajetória com base na rubrica que vocês definiram.

02:41 Em seguida, enviaremos esses traces de volta ao LangSmith para criar um dataset que usaremos nos trabalhos de fine-tuning supervisionado. Vamos começar a usar o SmithTune. Primeiro, vou executar o comando de ajuda para ter uma ideia dos comandos disponíveis e conhecer a estrutura geral da CLI. Vejo que preciso executar SmithTuneDoctor. Assim, podemos ver que todas as minhas chaves de API e demais configurações estão definidas. Outro ponto importante que notei é que preciso confirmar os direitos sobre os dados. Já fiz isso.

03:12 Assim, vemos a versão salva que posso usar como referência pelo restante do uso da CLI. Agora vou começar a trabalhar com meu coding agent, que vai me ajudar no processo de obtenção do dataset. Copiei este comando, que pede ao SmithTune para buscar trajetórias do meu projeto de tracing de revisão do OpenSWE. Esse é um coding agent open source que usamos bastante na LangChain. Quero 50 trajetórias-alvo e um tamanho máximo de 500 candidatos para ele analisar. Forneci o projeto, o workspace, os IDs e também um filtro para ajudar a identificar os traces corretos. Ótimo.

03:44 Podemos ver que meu coding agent está raciocinando sobre como precisa buscar essas trajetórias. Ele está baixando um conjunto de candidatos e, em seguida, faremos uma avaliação separada pelo conselho de modelos, depois de definirmos uma rubrica do que consideramos bom. Certo, vemos que a busca foi concluída e estamos prontos para a triagem pelo conselho. Vou pedir ajuda para definir uma rubrica do que é uma boa trajetória. Ele está me perguntando o que o conjunto de treinamento dos avaliadores deve priorizar. Esta primeira sugestão parece boa. Podemos ver que ele me ajudou a elaborar uma rubrica.

04:14 Parece ótimo. Agora vou iniciar a avaliação. Vou usar DeepSeq 4.1 Flash e GLM 5.3 Flash, limitando a avaliação a dois avaliadores. Os dois precisam concordar em manter um exemplo para que ele continue no dataset. Voltarei quando esta etapa terminar. Ótimo, vemos que temos 50 trajetórias aprovadas pelos dois avaliadores. Agora vou conferir este relatório e confirmar que estou satisfeito com a estrutura dos relatórios aceitos. Sim, parece ótimo. Agora vou pedir ao meu coding agent do SmithTune que use o comando de envio do dataset

04:47 para enviar isso ao LangSmith. Depois de analisar o conteúdo, sei que ele contém algumas informações de identificação pessoal. Vou cuidar disso e removê-las depois que estiver no LangSmith. Excelente, vemos que o envio do dataset foi concluído. Vou conferir agora. Ótimo, estamos prontos para a próxima etapa do processo. Agora que temos nosso dataset de trajetórias de referência, vamos prepará-lo para o treinamento. Vamos começar pelas trajetórias que criamos e escolher um provedor, Baseten ou Fireworks, além de um modelo-base. Em seguida, vamos criar as divisões para treinamento,

05:18 validação e teste, que usaremos ao treinar o modelo e depois ao avaliá-lo para ver seu desempenho. Agora vamos executar a etapa de preparação no SmithTune. Vamos especificar o provedor de treinamento; usaremos o Base 10. Vamos passar o ID do workspace e o ID do dataset que acabamos de criar. Também vamos passar o modelo que queremos usar. Neste caso, usaremos o Qwen 3.8 27B, um ótimo modelo para fine-tuning supervisionado. Ele equilibra bem velocidade e precisão e tem um comprimento de sequência grande, permitindo treinar com trajetórias mais longas.

05:50 Vou voltar quando isso estiver concluído. Ótimo. Agora que esta etapa de preparação terminou, vemos algumas informações gerais que serão úteis antes de iniciarmos as próximas ações. Elas incluem o modelo que vamos treinar, o comprimento da sequência, quem é nosso provedor, quantos exemplos foram preparados, quantos foram rejeitados e também um pouco mais de informação sobre as divisões entre treinamento e teste. Neste caso, vamos treinar com 41 exemplos, testar com cinco e reservar quatro para validação. Isso nos ajuda a separar os dados e garantir que nenhum exemplo usado no treinamento vaze para os conjuntos de validação ou teste.

06:21 Para fins de demonstração, meu dataset é bem pequeno. Se você fosse executar um trabalho de verdade, seria melhor ter uma variedade muito maior de exemplos de teste, validação e treinamento. Antes de começar o treinamento, vamos executar SmithTune plan. Isso mostra o modelo selecionado, o número de exemplos e configurações como taxa de aprendizado, tamanho do lote e número de épocas. Revise essas informações e, em seguida, passe as configurações escolhidas para o comando de treinamento. Ótimo, agora que estou quase pronto para treinar, primeiro vou executar SmithTune plan, só para garantir que está tudo em ordem antes de iniciar um trabalho de treinamento pago.

06:53 Isso vai nos mostrar algumas informações importantes, além de outras configurações relevantes do trabalho de treinamento que será executado. Está tudo certo para mim, e agora estou pronto para iniciar o trabalho de treinamento. Agora, execute SmithTune train para começar o fine-tuning com Base 10 ou Fireworks. No nosso caso, usaremos Base 10. Durante o treinamento, o SmithTune verifica o desempenho no conjunto de validação e seleciona o checkpoint com a menor perda de validação. Ótimo. O plano que geramos antes parece bom, e agora estou pronto para começar o treinamento. A CLI selecionará o checkpoint

07:24 com a menor perda de validação, compare-o com nosso modelo base usando nossos dados de teste reservados e publique os resultados no LangSmith. A flag confirmed autoriza o treinamento e a avaliação pagos. E, assim que nosso job de treinamento terminar, como fornecemos o comando de avaliação, receberemos um link para a visualização de comparação de experimentos do LangSmith, onde poderemos ver os resultados do nosso job de fine-tuning. O modelo Qwen base está à esquerda, e o modelo com fine-tuning está à direita. Cada linha representa uma trajetória reservada, com previsões individuais de reprodução e explicações do avaliador logo abaixo.

07:57 O gráfico de feedback resume a concordância com as ações de referência registradas, e podemos expandir uma linha para inspecionar o que cada modelo previu e por que passou ou falhou. Esse não foi um job muito grande. E, de novo, eu não esperaria ver muito benefício no modelo com fine-tuning que temos aqui. Mas podemos ver que nossa concordância média com o avaliador, ou com a trajetória de referência, é um pouco maior no nosso Qwen com fine-tuning do que no Qwen base. E, portanto, de forma promissora, podemos ver o valor que o fine-tuning desse modelo trouxe para essa tarefa específica. Por fim, temos a etapa de deploy. Se os resultados atenderem à sua meta de qualidade,

08:29 use SmithToonDeploy para disponibilizar o modelo ajustado e conectá-lo à sua aplicação. Se os resultados precisarem de melhorias, use a avaliação para refinar seus exemplos ou as configurações de treinamento e, em seguida, execute outra iteração. Esse é o workflow: criar, preparar, planejar, treinar, avaliar e fazer o deploy. Experimente o SmithToon no GitHub. O link está na descrição, e adoraríamos saber o que você criar.

Transcrição original

[00:00] Go from your agent’s traces to a fine-tune model in one workflow. Hi, it’s Jake from LangChain and today we’re launching LangSmith fine-tuning in public beta with SmithTune, a CLI to allow you to post-train models from your LangSmith traces in one workflow. Supervised fine-tuning, or SFT, teaches a model desired behavior through golden examples. For agents, that might mean choosing the right tools, following a particular workflow, recovering from errors, or knowing when to ask for clarification.

[00:34] You might use SFT to specialise a large model for your application, distill a frontier model’s behaviour into a smaller model, or establish a starting policy for reinforcement learning. Depending on your goal and training data, it can improve task accuracy and tool reliability, or reduce cost and latency by teaching more efficient behavior. Getting there from your agent traces usually means manually stitching together several steps, selecting good traces, preserving their messages and tool context,

[01:06] formatting training data, running fine-tuning, evaluating whether the resulting model actually improves, and then deploying that model if you like the results. In this video, we’ll walk through how Smith-Toon makes this process seamless in one end-to-end workflow. Let’s dive in. Firstly, it’s extremely important that we have a strong representation of the context behind each action that our agent took. In Langsmith, this is represented in the trajectory format, where we can see a detailed reconstruction of the agent’s trajectory as it went out to complete a particular task.

[01:38] We want to capture what the agents saw at each turn, And so it’s important to have a representation where we can see everything that the agent referenced, including things like the tools available to it at that turn. This is particularly important because in some cases, for long-running agents, the tools available to the agent might change at each turn, and so we need to have a strong representation of that. Fortunately, Lang Smith’s trajectory format allows us to reconstruct this context in the exact way that we need for our post-training jobs. SmithTune starts with your Lang Smith tracing project, where we have sample trajectories.

[02:11] From there, we’ll pull down those trajectories, optionally applying any filters to store them in a local directory. Next, you and your coding agent that’s using the Smith-Hoon CLI will work to define a task-specific rubric to help define what’s a good trajectory. This will help us keep the trajectories that we wanna use as our golden examples. That rubric will then be passed to a model council with three independent reviewers who will each decide whether to keep or to drop a trajectory based on the rubric that you’ve worked to define.

[02:41] We then upload those traces back to LangSmith to have a created dataset that we’ll use in our supervised fine tuning jobs. Let’s type into using SmithToon. First, I’m gonna run the help command just to get a sense of what commands are available to me and to get a general layout of the CLI. I can see that I need to run SmithToonDoctor. So we can see that all my API keys and everything are set here. Another important part that I saw was that I need to confirm the data rights. I’ve gone ahead and done that already.

[03:12] And so we can see that save version that I can reference for the remainder of using the CLI. Now I’m gonna start working with my coding agent that’s gonna help me in this dataset pull process. I’ve got this command copied here that asks Smithtoon to pull trajectories from my openSwee reviewer tracing project. This is an open source coding agent that we use a lot at Langchain. I want 50 target trajectories with a max candidate size for it to go and look through of 500. I’ve given it the project, workspace, IDs, as well as a filter so that it can help identify the correct traces. Great.

[03:44] We can see that my coding agent is reasoning about the way that it needs to pull these trajectories. We can see that it’s downloading a candidate pool and then we’ll separately do a model council review after we define a rubric of what good looks like for us. Okay, we can see that our pull is complete and we’re ready for our council triage. I’m gonna ask it to help me define a rubric what good looks like for these trajectories. We can see that it’s asking me what the reviewer training set should prioritize. This first suggestion looks good. We can see that it’s helped me design a rubric.

[04:14] This looks great. Now I’m gonna kick off the judging. I’m gonna use DeepSeq 4.1 Flash and GLM 5.3 Flash, so limit it to two judges. Both of them need to agree on keeping an example for us to continue to have it in the dataset. I’ll come back when this stage is finished. Awesome, we can see that we’ve got 50 trajectories that have been approved by both judges. I’m gonna now go and look at this report and just confirm that I’m happy with the structure reports being accepted. Yep, it looks great. So now I’m gonna tell Smith to my coding agent to please use the dataset push command

[04:47] to upload this to Langsmith. I know that it contains some PII after looking through it. I’ll take care and remove that once it’s in Langsmith. Amazing, and we can see that the dataset upload has completed. I’ll go and check that out now. Great, we’re ready for the next step in our process. Now that we have our data set of golden trajectories, we’re gonna prepare it so that it’s ready for training. We’ll start from our created trajectories and then go and choose a provider, either Base 10 or Fireworks, as well as a base model. From there, we’ll create the training,

[05:18] validation and test splits that we’ll use when we train our model and then when we evaluate it to see how it performs. Now we’ll run the prepare stage in SmithToon. We’re gonna specify our training provider, We’ll be using base 10. We’ll pass the workspace ID and the dataset ID for the dataset that we just created. And we’ll also pass the model that we want to use. In this case, we’re going to be using Quen 3.8 27B, which is a great model for supervised fine tuning. It balances speed and accuracy well and has a large sequence length so that we can train on longer trajectories.

[05:50] I’ll check back in once this is finished. Awesome. Now that this prepare step is finished, we can see some high level information that’ll be useful for us before we kick off the next actions. That includes things like the model that we’re gonna be training, the sequence length who our provider is, how many examples were prepared, how many were rejected, and also understand a little bit more about the train and test split. In this case, we’re gonna train on 41 examples, test on five and keep four for validation. This helps us with our data separation and make sure that none of the examples that we train on leak into our validation or test sets.

[06:21] Now for demonstration purposes, my data set size is quite small. If you were running an actual job, you’d wanna have a much broader range of test validation and training examples. Before starting training, we’ll run SmithTune plan. This shows the selected model, the number of examples, and settings such as learning rate, batch size, and epochs. Review these, then pass your chosen settings to the training command. Great, now that I’m nearly ready to train, I’m first gonna run SmithTune plan, just to make sure that everything looks in order before I kick off a paid training job.

[06:53] This is gonna tell us some key information, as well as some other key configurations or the training job that will run. This all looks good to me and now I’m ready to kick off my training job. Now run SmithTune train to start fine tuning with base 10 or fireworks. In our case, we’ll be using base 10. During training, SmithTune checks performance on the validation set and selects the checkpoint with the lowest validation loss. Awesome. And so the plan that we generated earlier looks good and now I’m ready to start training. The CLI will select the checkpoint

[07:24] with the lowest validation loss, compare it against our base model our held out test data and publish the results to Langsmith. The confirmed flag authorizes the page training and evaluation. And once our training job is finished, because we provided the evaluate command, we’ll be provided with a link to the Langsmith experiment comparison view to see the results of our fine tuning job. The base quen model is on the left, and the fine tune model is on the right. Each row represents a held out trajectory with individual replay predictions and judge explanations underneath.

[07:57] The feedback chart summarizes agreement with the recorded reference actions and we can expand a row to inspect what each model predicted and why it passed or failed. Now this wasn’t a very large job. And again, I wouldn’t expect to see much of a benefit in the tune model that we have here. But we can see that our average agreement with the judge or golden trajectory is slightly higher on our fine tune quen compared with our base quen. And so promisingly, we can see the value that fine tuning this model is done for this particular task. Finally, we have the deploy step. If the results meet your quality target,

[08:29] use SmithToonDeploy to serve the tuned model and connect it to your application. If the results need work, use the evaluation to refine your examples or training settings, then run another iteration. That’s the workflow. Create, prepare, plan, train, evaluate, and deploy. Try SmithToon on GitHub. The link is in the description and we’d love to hear what you build.