Latest / Entre Chaves / Snippet #20 Como configurar agentes autônomos no Copilot

Transcript

Snippet #20 Como configurar agentes autônomos no Copilot · Entre Chaves

• 0:00
  Olá pessoal, meu nome é Breno, eu sou desenvolvedor aqui na
• 0:03
  DTIE. Hoje nesse snipet a gente vai
• 0:05
  falar um pouco sobre a criação de agentes no copylet.
• 0:08
  Nesse vídeo você vai aprender a criar agentes do zero, entender
• 0:11
  a anatomia desses elementos e como configurar elas da melhor
• 0:15
  forma, deixando elas restritas o suficiente para que elas
• 0:18
  consigam fazer trabalho da melhor forma.
• 0:20
  O ecossistema do copylet permite que a gente consiga criar várias
• 0:24
  ferramentas que vão auxiliar em diferentes etapas ali do
• 0:28
  processo. Dentre elas a gente tem.
• 0:30
  Das instructions, os hooks, as skills e os agentes.
• 0:34
  Então vamos começar falando das instructions.
• 0:37
  Todas essas ferramentas irão ficar nessa pasta ponto GitHub
• 0:40
  na raiz do projeto quando a gente estiver organizando esse
• 0:44
  ecossistema, é interessante já deixar as pastas criadas no
• 0:47
  ponto GitHub ou o próprio agente quando a gente solicitar a
• 0:51
  criação dessas ferramentas. Vai criar essas pastas para
• 0:54
  gente na pasta do ponto GitHub. Um detalhe interessante é que
• 0:57
  nesse momento de desenvolvimento de skills, agentes e hooks e
• 1:01
  structions, nós não precisamos criar tudo isso na mão.
• 1:05
  A própria LLMO, nosso próprio modelo, vai conseguir criar isso
• 1:08
  com base no que a gente solicitar para ele, em linguagem
• 1:11
  natural. Então, a gente consegue ser
• 1:13
  muito específico no que a gente quer se resguardar, que tipo de
• 1:17
  ferramenta que a gente quer criar e o que que a gente quer
• 1:20
  que ela faça para conseguir. Gerar elas automaticamente,
• 1:24
  usando os nossos, os nossos próprios agentes, aqui, o nosso
• 1:26
  próprio modelo do Copilot. Então, para começar com as
• 1:29
  instructions, eu vou criar uma pasta instructions.
• 1:33
  Então, essa primeira instruction, quero que ela
• 1:35
  considere os padrões de projeto dry, Kiss e solid para todos os
• 1:47
  códigos que eu gerar nesse. Ecossistema quando eu odeio esse
• 1:54
  comando do barra creating instruction, eu estou chamando
• 1:57
  uma skill do próprio compadre para criação de instructions
• 2:00
  personalizados aqui no meu projeto.
• 2:02
  Então, como a gente pode ver, a instruction foi gerada com o
• 2:06
  nome solid dry Kiss instructions ponto MD todas as instructions
• 2:10
  tem o sufixo instructions ponto MD na sintaxe da nossa
• 2:15
  instruction, a gente precisa ter uma descrição e um apply to.
• 2:19
  A descrição vai simplesmente resumir o que essa instruction
• 2:22
  vai fazer. E o apply two, a gente consegue
• 2:24
  definir que tipos de arquivos que essa instruction vai ser
• 2:27
  aplicado, em que ocasiões a gente vai aplicar essa
• 2:31
  instruction. Então, como a gente pode ver,
• 2:33
  né? Nessa instruction que eu estou
• 2:34
  definindo os padrões aqui de projeto que eu quero aplicar,
• 2:38
  né? Nos nas minhas geração de
• 2:39
  código. Agora falando sobre os rooks, os
• 2:42
  rooks são ferramentas que podem ser aplicadas.
• 2:46
  Como guard raios do nosso uso de e a.
• 2:48
  Então, quando eu vou mandar um comando aqui no chat, quando o
• 2:51
  nosso agente está executando, está tentando fazer alguma coisa
• 2:54
  rodar um comando no terminal, o Hulk vai ser chamado
• 2:57
  automaticamente para prevenir algumas coisas quando for
• 3:01
  executado um comando no terminal.
• 3:03
  Eu quero que seja validado se esse comando é algo destrutivo.
• 3:06
  Por exemplo, um RM trac RF que poderia deletar o nosso projeto
• 3:11
  aqui se for executado de uma forma incorreta, né?
• 3:14
  Então os hooks conseguem ser rodados em determinadas etapas
• 3:18
  do processo. Podemos ter hooks que se ativam
• 3:21
  antes da ferramenta ser chamada, podemos ter hooks que se aplicam
• 3:25
  depois da ferramenta ser chamada, e isso vai variar de
• 3:28
  acordo com a necessidade. Então agora vou chamar o comando
• 3:32
  barra create Hulk. Crie um Hulk que vai impedir que
• 3:41
  comandos destrutivos sejam executados no terminal, vai
• 3:49
  criar uma pastinha chamada hooks e vai gerar esse Hook com base
• 3:53
  no que eu solicitei aqui. Como a gente pode ver aqui, a
• 3:56
  gente tem. 3 arquivos que foram gerados para esse Hulk.
• 4:00
  Um deles é o Jason. Esse Jason é apenas a
• 4:04
  configuração do Hulk. Eu estou especificando que eu
• 4:07
  quero um Hulk de preto Youse, que é para ser usado antes da
• 4:11
  ferramenta executar, que é para a gente impedir que comandos
• 4:14
  destrutivos sejam utilizados. E um detalhe interessante é que
• 4:17
  como a gente pode estar usando o copality aqui?
• 4:21
  Em ecossistemas diferentes, em sistemas operacionais
• 4:23
  diferentes, o Hulk automaticamente, quando a gente
• 4:26
  pede pro compallet gerar, ele vai ser gerado tanto script de
• 4:29
  Power Shell quanto um bash pra funcionar em qualquer
• 4:32
  ecossistema que a gente esteja rodando, em qualquer sistema
• 4:35
  operacional. Então aqui no nosso Hulk a gente
• 4:37
  tem algumas especificações nesse script que vão impedir esses
• 4:41
  comandos, né? Vão validar esse comando com o
• 4:43
  rejex, né? Vai entender o que que ele está
• 4:45
  solicitando ali pra evitar esse comando destrutivo.
• 4:49
  Agora a gente vai falar das skills.
• 4:51
  Que são habilidades que a gente consegue dar para o nosso
• 4:53
  modelo, para ele executar coisas que a gente tem o conhecimento e
• 4:58
  quer passar para LLM, né? Esse conhecimento a gente vai
• 5:01
  gerar aqui um skill e a gente vai ver como que vai ser a
• 5:04
  anatomia dessa skill. Para a gente entender como
• 5:06
  funciona essa estrutura. Vou criar aqui um skill usando
• 5:10
  barra, create skill e na minha skill eu vou pedir para que ela
• 5:14
  consiga definir como o time implementa.
• 5:20
  Recursos hest, como deve ser a estrutura de pastas, a ordem de
• 5:27
  implementação, as convenções. E aqui nas convenções eu
• 5:32
  coloquei, né, que eu quero usar as rotas para validação, RFC
• 5:35
  7807 para erros e que as rotas sejam versionadas numa barra v
• 5:41
  um. Vou solicitar isso aqui.
• 5:43
  Aqui dentro da pasta skills temos uma pasta com o nome da
• 5:47
  skill. Hest up API standards e dentro
• 5:50
  dessa pasta a gente vai ter as especificações da nossa skill.
• 5:54
  Uma delas é o nosso arquivo skill ponto MD.
• 5:57
  Então cada skill tem sua pasta respectiva e um arquivo padrão
• 6:01
  que sempre vai ter em todas as skills, que é o skill ponto MD.
• 6:04
  Nesse skill ponto MDA gente vai ter o nome da skill, a descrição
• 6:10
  e o argument 20, o nome dessa skill aqui nesse arquivo.
• 6:14
  Tem que ser exatamente o mesmo da pasta onde ele está incluído.
• 6:18
  Então, além desse arquivo skill, a gente tem uma pasta de asset e
• 6:22
  uma pasta de referências que vão auxiliar a nossa skill.
• 6:26
  Então a nossa skill vai ter referências a essas pastas para
• 6:29
  auxiliar, né? Então aqui a gente vai ter no
• 6:31
  asset templates que a nossa skill vai utilizar na hora de
• 6:35
  validar esse desenvolvimento de software, de de de recursos
• 6:39
  hest. E essas referências aqui, que
• 6:41
  são convenções. Que a gente mesmo especificou
• 6:44
  ali, em linguagem natural, que a gente queria que essa skill
• 6:46
  fosse capaz de validar no nosso desenvolvimento.
• 6:50
  Agora a gente chega pra parte mais interessante, que são os
• 6:53
  agentes do Copilot. Eu quero criar aqui agora um
• 6:56
  agente e pra isso eu vou chamar o comando barra create agent.
• 7:00
  E eu quero que seja criado um agente de desenvolvimento de
• 7:04
  aplicações back end rest em DOT net na descrição do nosso
• 7:09
  agente, a gente está aqui especificando o que que esse
• 7:11
  agente vai fazer. Aqui eu estou especificando
• 7:14
  quais rooks vão ser aplicados nesses agentes.
• 7:16
  E eu também tenho aqui uma parte que é muito importante, que são
• 7:20
  as ferramentas que esse agente vai ter acesso.
• 7:22
  Então aqui eu consigo clicar em configur tools, que vai me
• 7:25
  mostrar uma lista de ferramentas que esse agente vai poder
• 7:29
  acessar. E eu vou poder delimitar quais
• 7:32
  ferramentas que ele vai conseguir acessar.
• 7:34
  Então eu posso impedir o meu agente, por exemplo, de editar o
• 7:36
  meu código? Eu posso permitir ou não que o
• 7:38
  meu agente execute comandos no terminal?
• 7:40
  Posso pedir que o meu agente sempre gere um tio do list
• 7:44
  quando ele estiver executando ali no chat.
• 7:46
  Aqui a gente pode ver que os MCPS estão aparecendo aqui,
• 7:49
  todos os meus MCPS configurados e eu consigo dar pro meu agente.
• 7:54
  As ferramentas também dos MCPS. Então eu consigo criar agentes
• 7:58
  específicos para lidar com ferramentas externas também.
• 8:01
  Então, depois disso, a gente tem de fato o escopo do nosso
• 8:04
  agente, né? O corpo dele aqui, explicando
• 8:06
  tudo o que ele vai fazer com o que que ele deve se preocupar
• 8:09
  com padrões de código, padrões de pastas, abordagem que se a
• 8:13
  gente vai usar na hora que estiver desenvolvendo, enfim,
• 8:16
  depois que eu crio o código. Uma coisa interessante seria
• 8:20
  revisar no próprio copality. Ele deu uma sugestão de criar um
• 8:23
  teste edneer DOT net aqui que vai testar o que eu vou entregar
• 8:27
  com meu agente de de back end coder.
• 8:29
  Então vou pedir pro cliente e aí a gente criar um teste edneer e
• 8:33
  também um code review. Que vai revisar o código criado
• 8:37
  com os padrões que a gente já definiu.
• 8:39
  Então aqui é Pra Ele criar 2 agentes.
• 8:41
  A gente vai ver isso acontecendo na prática.
• 8:43
  E no final de tudo, eu vou criar um agente orquestrador.
• 8:47
  Eu consigo criar um agente que vai orquestrar a execução de
• 8:51
  todos esses agentes aqui no meu fluxo.
• 8:53
  Então, se eu tenho um fluxo complexo, eu consigo fazer um
• 8:56
  agente orquestrador. Que passe por todas essas etapas
• 8:59
  e para cada uma delas, chame um agente específico que vai
• 9:02
  executar aquilo ali. Para deixar a coisa ainda mais
• 9:05
  organizada e mais funcional. Cada agente que é chamado abre
• 9:09
  uma nova sessão no copailut. Então, todo o contexto que o
• 9:12
  agente vai ter vai ser daquela execução que ele está realizando
• 9:17
  ali. E o orquestrador tem a visão
• 9:18
  geral do que está sendo construído.
• 9:20
  Então temos aqui o nosso code review e temos o nosso teste em
• 9:24
  dneer. Agora eu vou pedir para que o
• 9:28
  meu create agent crie um agente orquestrador que vai orquestrar
• 9:36
  a execução dos 3 agentes em sequência, então ao invés de eu
• 9:43
  chamar o meu back end coder, ver a execução, depois chamar o meu
• 9:47
  tester, ver a execução, o resultado, depois chamar o meu
• 9:50
  agente de code review. Eu posso chamar o meu agente de
• 9:53
  orquestrador, que vai fazer cada etapa, validar os resultados,
• 9:57
  entregar para o próximo agente e seguir todo o fluxo para que eu
• 10:01
  consiga validar isso só no final.
• 10:03
  Então aqui a gente tem o nosso agente orquestrador, tem uma
• 10:06
  breve descrição de como ele vai se comportar, as ferramentas que
• 10:09
  ele vai ter acesso e os agentes que ele vai controlar.
• 10:12
  Então aqui a gente vê o back end coder, o teste engineer e o code
• 10:16
  review, que são os agentes que a gente criou aqui anteriormente.
• 10:19
  Então o nosso agente orquestrador, ele tem etapas que
• 10:22
  ele vai seguir. Quando a gente chama ele, na
• 10:24
  etapa um implementação, vai chamar o back end coder, na
• 10:28
  etapa de teste, vai chamar o teste edneer, quando chegar na
• 10:31
  parte de revisão de código, vai chamar o code review.
• 10:34
  Essa é a nossa orquestração de agentes.
• 10:36
  Com isso a gente consegue seguir um fluxo inteiro, utilizar as
• 10:39
  skills, utilizar nossos hooks e as nossas instructions e criar
• 10:42
  11 ecossistema de harners robusto e essa orquestração de
• 10:45
  agentes que vai possibilitar? Que a gente execute tarefas de
• 10:49
  uma forma muito mais rápida e menos repetitiva e que exija
• 10:52
  menos prompts manuais no chat. Agora eu consigo chamar os meus
• 10:56
  agentes pra executar as minhas ações, pra mim pra acessar esses
• 10:59
  agentes. A gente vai ter aqui, né?
• 11:01
  Na Na janelinha de seleção aqui, que a que a gente consegue mudar
• 11:05
  entre o agente, o Esc e o pleno, os agentes que a gente criou
• 11:09
  numa lixinha, então. Se eu quiser só executar um
• 11:13
  deles, eu consigo chamar, né? Por exemplo, se eu quisesse só
• 11:16
  testar, eu chamaria o meu teste em dnir.
• 11:18
  Mas se eu quiser executar um fluxo inteiro, eu chamaria o
• 11:20
  orquestrator e solicitaria para ele.
• 11:24
  Desenvolva a feature de. Login de usuários e aí ele vai
• 11:30
  passar pelas 3 etapas pelos meus 3 agentes, o orquestrador vai
• 11:34
  organizar essa execução, então espero que tenham gostado, que
• 11:37
  tenham aprendido um pouco mais sobre os agentes no Copilot e
• 11:40
  até a próxima.