Crie um pull request no GitHub a partir de uma mensagem no Slack com Managed Deep Agents
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: Ship a GitHub PR From a Slack Message with Managed Deep Agents · Canal: LangChain · 03:07 · Assistir no YouTube
Tópicos: Agentes de IA, Automação de tarefas e workflows
O vídeo apresenta Patch, um agent criado com Managed Deep Agents que recebe solicitações pelo Slack e transforma ideias em pull requests no GitHub. Os exemplos mostram a criação de um botão para compartilhar pontuações e a alteração da cor de fundo de um jogo de Tetris. O apresentador explica como configurar o agent, as instruções, os canais do Slack, o acesso ao GitHub via MCP e um sandbox para escrever e testar código. Segundo o vídeo, o agent pode ser implementado com poucas linhas de código e publicado com um único comando.
Pontos-chave
Seção intitulada “Pontos-chave”- Patch recebe solicitações de funcionalidades pelo Slack e prepara pull requests no GitHub.
- Os pull requests incluem a descrição e as alterações de código para revisão antes da aprovação.
- Os exemplos apresentados são um botão para compartilhar pontuações e um fundo roxo no jogo de Tetris.
- O arquivo agent.py define o nome do agent e o modelo utilizado.
- As instruções descrevem o repositório, as tarefas e o comportamento esperado do agent.
- Managed Deep Agents Channels permite conectar o agent a um workspace do Slack.
- O acesso ao GitHub é configurado com GitHub MCP e um token armazenado como segredo em uma variável de ambiente.
- Um sandbox permite que o agent escreva e teste código.
- O apresentador afirma que a publicação do agent pode ser feita com um único comando.
Capítulos
Seção intitulada “Capítulos”| Início | Capítulo | Resumo |
|---|---|---|
| 00:00 | Patch cria pull requests a partir do Slack | O apresentador introduz Patch e demonstra como transformar uma ideia para o jogo de Tetris em um pull request. |
| 01:02 | Outro exemplo e configuração do agent | Patch altera a cor de fundo do jogo, e o apresentador começa a explicar como o agent foi criado com Managed Deep Agents. |
| 01:34 | Instruções e conexão com o Slack | O vídeo descreve os arquivos e instruções do agent e a configuração do canal do Slack. |
| 02:34 | Acesso ao GitHub, sandbox e publicação | O apresentador mostra o uso do GitHub MCP, a configuração do sandbox e a publicação do agent com um comando. |
Citações
Seção intitulada “Citações”É um agent que pode ser chamado pelo Slack para escrever pull requests no GitHub. — 00:00
Tudo o que fizemos foi chamar Patch pelo Slack, descrever a funcionalidade que queríamos, e ele criou um pull request no GitHub. — 00:32
Com Managed Deep Agents, você consegue fazer isso com apenas algumas linhas de código. — 01:34
Publicar o agent é apenas um comando. — 03:07
Conceitos e entidades
Seção intitulada “Conceitos e entidades”- Patch (conceito): É o agent demonstrado no vídeo, que recebe pedidos pelo Slack e prepara pull requests no GitHub.
- Managed Deep Agents (ferramenta): É a solução da LangChain usada para criar e publicar o agent com poucas linhas de código.
- LangChain (empresa): É a empresa cuja solução Managed Deep Agents é apresentada no vídeo.
- Slack (ferramenta): É o canal pelo qual os usuários chamam Patch e descrevem as funcionalidades desejadas.
- GitHub (ferramenta): É a plataforma usada para acessar o código e criar pull requests para revisão.
- GitHub MCP (ferramenta): É a integração MCP usada para dar ao agent acesso a ferramentas do GitHub.
- Claude Sonnet 5 (modelo): É o modelo indicado no vídeo como usado pelo agent Patch.
- sandbox (conceito): É o ambiente configurado para que o agent escreva e teste código.
Tradução completa (pt-BR)
Seção intitulada “Tradução completa (pt-BR)”00:00 Quero mostrar este agent muito legal que criei usando os managed deep agents da LangChain. Gosto de chamá-lo de Patch. É um agent que pode ser acionado pelo Slack para escrever PRs do GitHub. E o melhor de tudo: foram necessárias apenas algumas linhas de código para criá-lo e fazer o deploy. Deixe-me mostrar como ele funciona. Meu colega de trabalho e eu gostamos de jogar Tetris nos momentos de folga. Então, criamos nossa própria versão do jogo, que podemos modificar do jeito que quisermos. A maioria das nossas conversas sobre desenvolvimento e das nossas ideias acontece no Slack, como ocorre com a maioria das equipes de software. Por isso, o Patch nos permite
00:32 implementar imediatamente as ideias que temos. Por exemplo, aqui mostrei uma pontuação da qual me orgulhava bastante, mas logo percebemos que compartilhar a pontuação por captura de tela não era o ideal e que precisávamos de um botão de compartilhamento. Tudo o que fizemos foi chamar o Patch pelo Slack, descrever o recurso que queríamos e deixar que ele criasse um PR do GitHub. Ele inclui a descrição, as alterações no código, tudo. Vamos aprová-lo e testá-lo. E pronto. Aqui está o botão de compartilhamento.
01:02 Deixe-me mostrar outro exemplo. Aqui, Shawn quer mudar a cor de fundo para roxo. Por mim, tudo bem. Então, vou marcar o Patch, descrever o recurso e deixar que ele faça o trabalho. Mais uma vez, ele cria um rascunho de PR do GitHub, e podemos analisá-lo e conferir a descrição e as alterações no código. Para mim, está tudo certo, então vou aprová-lo. E aqui está o novo jogo. O fundo está roxo. Bem legal. Deixe-me mostrar como foi fácil criar esse agent usando managed deep agents.
01:34 Pensando bem, esse agent precisa poder ser acionado pelo Slack. Precisa ler e escrever no GitHub. E provavelmente também precisa de uma sandbox para escrever o próprio código e testá-lo. É muita coisa para pedir a um agent, mas, com managed deep agents, dá para fazer tudo isso com apenas algumas linhas de código. Os MDA são diretórios, e o nome e a localização do arquivo determinam sua função. Então, este arquivo, agent.py, define o agent com um nome e um modelo. Dei a ele o nome Patch, e ele está usando o Claude Sonnet 5.
02:04 No arquivo MD, especifico o que o agent deve fazer. Indiquei o repo do GitHub que contém a base de código e disse que ele deve corrigir bugs e implementar recursos. Também há seções que descrevem o comportamento e o procedimento que ele deve seguir. Essas são as informações que o agent recebe a cada turno da conversa. Mas, como dissemos, o agent precisa ser acionado pelo Slack. É um pedido bem substancial, mas, com os canais dos Managed Deep Agents, isso é feito com apenas algumas linhas de
02:34 código. Quando você faz o deploy do MDA pela primeira vez, ele pede que você autorize e conecte um workspace, mais ou menos assim. E é só isso. É muito simples. Para o GitHub, decidi usar o GitHub MCP, e você pode ver as ferramentas às quais dei acesso ao agent. É importante notar que o token de acesso está na variável patch GitHub, que é apenas um segredo que configurei por meio de uma variável de ambiente. E a sandbox é igualmente fácil: são apenas algumas linhas. Importe a função de sandbox definida e, em seguida, defina uma. E é basicamente
03:07 isso sobre o Patch. As três grandes coisas que queríamos estão todas conectadas ao agent com apenas algumas linhas de código. E o melhor de tudo: fazer o deploy do agent requer apenas um comando. Se quiser saber mais sobre Managed Deep Agents, incluí alguns links úteis na descrição. E comece a criar.
Transcrição original
[00:00] I want to show you this really cool agent that I built using LangChain’s managed deep agents. I like to call it Patch. It’s an agent that can be called through Slack to write GitHub PRs. And best of all, it only took a few lines of code to write and to deploy. Let me show it off to you. My co-worker and I like playing Tetris during moments of downtime. And so, we coded up our own version of the game that we can change that we’re liking. Most of our development discussions and ideas happen in Slack, just like with most software teams. So, Patch allows us
[00:32] to immediately implement the ideas that we come up with. Like here, I showed off a score I was pretty proud of, but we quickly realized that sharing the score through screenshot is not the way to go, and we needed a share button. All we did was called Patch from within Slack, described the feature that we wanted, and it went off and wrote a GitHub PR. It has the description, code changes, everything. Let’s approve it and test it out. And there you go. There’s the share button.
[01:02] Let me show you another example. Here, Shawn wants to change the background color to purple. I’m cool with that. So, I’ll tag Patch, describe the feature, and let it do its work. It again drafts a GitHub PR, and we can review it, check the description, the code changes. It all looks good to me, so I’ll approve it. And now, here’s the new game. The background is purple. Pretty cool. Let me show you just how easy it was to create this agent using managed deep agents.
[01:34] When you think about it, this agent needs to be able to be called from Slack. It needs to read from and write to GitHub. And it also probably needs a sandbox to write its own code and test it. That’s a lot of things to want out of an agent, but with managed deep agents, you can do that with just a few lines of code. MDs are directories, and the file’s name and location determines its role. So, this file, agent.py, defines the agent with a name and a model. So, I’ve called it Patch and it’s running Claude Sonnet 5.
[02:04] The instructions on MD file is where I specify what the agent should do. I pointed it to the GitHub repo that has the code base, and I’ve told it that it should solve bugs and implement features. There’s also sections describing the behavior and procedure it should follow. This is the information that the agent receives at every turn of the conversation. But, as we said, the agent needs to be called from Slack. This is a pretty substantial request, but with Managed DB Agents channels, this is done with just a couple lines of
[02:34] code. When you deploy the MDA for the first time, it will ask you to authorize and connect a workspace, kind of like this. And that’s really all there is to it. It’s very simple. For GitHub, I decided to use the GitHub MCP, and you can see the tools that I’ve given the agent access to. Importantly, the access token is found in this patch GitHub variable, which is just a secret that I’ve configured through an environment variable. And for the sandbox, it’s just as easy, only a couple of lines. Import the defined sandbox function and then actually define one. And that’s pretty
[03:07] much it for what Patch is. Those three big things that we wanted, all hooked to the agent with just a couple of lines of code. And best of all, deploying the agent is just a single command. If you want to learn more about Managed DB Agents, I’ve included some helpful links in the description and get started with building.