Nesta segunda parte, vou dar continuidade no assunto de uso de IA em times de tecnologia. Compartilharei alguns casos de uso práticos, trazendo componentes novos em alguns fluxos de trabalho já conhecidos.

📌 Contexto

Dentro das rotinas de times de engenharia de software, boa parte do tempo de execução é gasto dentro das IDEs (VSCode, por exemplo), ferramentas de gestão de projetos (Jira, por exemplo), ferramentas de versionamento de código (Github, por exemplo), issues, pull requests, code reviews, etc.

Além disso, com a intensificação do uso de IA, eventualmente códigos pode ser copiados em ferramentas de LLMs, como o ChatGPT, o Claude, o Gemini, para insights ou até mesmo para execução de tarefas.

Essa variabilidade de ferramentas e fluxos de trabalho tendem a prejudicar a produtividade e a qualidade do trabalho, além de aumentar o risco de erros humanos.

💡 Proposta de Solução

A rotina dos times de engenharia é repleta de ferramentas, contextos e integrações. Mas, e se fosse possível unir tudo isso em um fluxo inteligente, automatizado e seguro, sem sair do ambiente de desenvolvimento?

Minha proposta é criar um ecossistema onde a IA potencializa as ferramentas já utilizadas no dia a dia, tornando o trabalho mais fluido, produtivo e auditável. Para isso, utilizo os seguintes elementos:

• Cursor IDE: Ambiente de desenvolvimento moderno, com integração nativa de IA, que acelera a produtividade e facilita automações.
• GitHub: Principal plataforma de versionamento de código e gestão de issues, amplamente adotada no mercado e com fácil integração.
• Issues do GitHub: Utilizadas para gerenciar tarefas e acompanhar demandas, garantindo rastreabilidade e simplicidade no acompanhamento.
• ChatGPT: IA escolhida para geração de código, automação de tarefas e análise, pela sua popularidade e facilidade de uso.

Adicionalmente, usei mais componentes, mais técnicos, mas que são fundamentais para o sucesso da automação:

• MCP (Model Context Protocol): O MCP é um protocolo aberto e modular, criado para padronizar a comunicação entre agentes de IA, ferramentas e ambientes de desenvolvimento. Ele permite que diferentes sistemas "conversem" de forma segura, auditável e extensível, tornando possível a automação de fluxos complexos sem depender de integrações proprietárias ou scripts frágeis. O MCP está rapidamente se tornando o padrão de mercado para conectar agentes inteligentes a ferramentas reais, assim como o Docker fez para o deploy de aplicações.

• Docker como Proxy MCP: O Docker evoluiu para ser mais do que apenas um ambiente de containers: agora, com o Docker MCP Catalog e Docker MCP Toolkit, ele atua como um proxy seguro e centralizado para execução de agentes MCP. Isso significa que você pode rodar servidores MCP e conectar suas ferramentas e agentes de forma isolada, auditável e com gerenciamento de credenciais integrado, tudo com a simplicidade e segurança já conhecidas do Docker. O Docker MCP permite que qualquer desenvolvedor utilize e distribua ferramentas MCP com a mesma facilidade de um docker run, eliminando a complexidade de setup e aumentando a confiança no ecossistema.

Para fechar, a solução tem um último elemento, ao qual chamei de Github MCPilot.

O que é o Github MCPilot?

O Github MCPilot é um prompt que montei e apliquei como uma Cursor Rule (https://www.cursor.com/docs/rules), que tem o papel de se comportar como um agente de IA dentro da IDE.

O objetivo é simples:

Permitir que você converse com o seu GitHub de forma segura, prática e automatizada, sem sair do seu ambiente de desenvolvimento.

Características e Benefícios

O Github MCPilot foi projetado para ser um agente CLI interativo, seguro e realmente funcional para operações no Github, indo muito além de simples simulações. Veja os principais diferenciais:

• Saudação personalizada e arte de apresentação: Sempre inicia a sessão com uma saudação personalizada ao usuário, seguida de uma arte exclusiva, criando uma experiência única e acolhedora.

• Validação automática do ambiente: Antes de qualquer ação, valida se as configurações MCP para Github estão corretas, garantindo que todas as operações sejam executadas de forma segura e auditável.

• Operações reais e guiadas: Executa operações reais de leitura e escrita no Github via MCP, guiando o usuário por um menu interativo numerado, com ícones e explicações claras para cada comando disponível.

• Wizard de configuração: Antes do uso, conduz o usuário por um passo a passo para coletar todas as configurações necessárias, facilitando o setup mesmo para quem não é especialista.

• Menu adaptativo: O menu de comandos é adaptado conforme as permissões do usuário e as capacidades MCP disponíveis, sempre validando o acesso antes de executar qualquer ação.

• Logging estruturado e detalhado: Todas as interações podem ser registradas em logs estruturados, incluindo modelo de IA utilizado, tokens consumidos, comando executado, parâmetros, resultado real ou erro, sempre seguindo o padrão recomendado para auditoria e rastreabilidade.

• Guia prático e validação de ambiente: Inclui opções no menu para consultar um guia prático de uso real via MCP e para validar o ambiente, promovendo boas práticas e facilitando o aprendizado.

• Proatividade e experiência moderna: O agente é proativo, explica cada etapa, coleta parâmetros necessários, sugere boas práticas e alerta sobre operações sensíveis, proporcionando uma experiência semelhante a um CLI moderno e seguro.

• Retorno ao menu principal: Após cada operação, retorna automaticamente ao menu principal, permitindo que o usuário execute múltiplas ações de forma fluida até optar por sair.

Essas características fazem do Github MCPilot uma solução amigável para automação de fluxos de engenharia no Github.

🚀 Casos de Uso

Conforme citado na parte 1 deste artigo, vou compartilhar alguns casos de uso práticos, trazendo componentes novos em alguns fluxos de trabalho já conhecidos.

📦 Case 1: Criação Automatizada de Repositório

A automação da criação de repositórios permite padronizar projetos, acelerar o onboarding e garantir rastreabilidade. O usuário solicita a criação de um novo repositório com README e .gitignore via linguagem natural.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant 👤 Usuário
    participant 🤖 MCPilot
    participant 🐙 GithubAPI
    participant 📦 Repositório
    👤 Usuário->>🤖 MCPilot: Solicita criação de repositório
    🤖 MCPilot->>🐙 GithubAPI: Cria repositório
    🐙 GithubAPI-->>📦 Repositório: Repositório criado
    📦 Repositório-->>👤 Usuário: Exibe link e sucesso

Prompt

📝 Prompt enviado:

Agora quero que vc crie um novo repositório chamado golang_project_template, com uma estrutura básica para desenvolvimento de projetos. Considere:

• iac
• docs
• README

Inclua outras pastas ou recomendações para este tipo de projeto

🤖 Resposta da IA:

Repositório golang_project_template criado com sucesso!

Estrutura inicial recomendada já está disponível, incluindo:

• cmd/ (binários)
• pkg/ (código reutilizável)
• internal/ (código privado)
• api/ (definições de API)
• configs/ (configurações)
• scripts/ (scripts utilitários)
• build/ (build/CI)
• deployments/ (manifests de deploy)
• iac/ (infraestrutura como código)
• docs/ (documentação)
• tests/ (testes automatizados)
• .gitignore (padrão Go e mercado)
• README.md (explicativo e com recomendações)

Link do repositório: https://github.com/tiagonpsilva/golang_project_template

Recomendações:

• Use cmd/ para separar binários.
• Coloque código compartilhado em pkg/ e privado em internal/.
• Documentação sempre em docs/.
• Scripts de infraestrutura em iac/.
• Testes em tests/.
• Configurações versionadas em configs/.

Toda a operação, estrutura e recomendações foram registradas no log estruturado conforme solicitado.

Se quiser adicionar exemplos de código, pipelines, templates de PR/issue ou outra melhoria, é só pedir!

Log Registrado

{
  "timestamp": "2025-05-28T00:55:43.3NZ",
  "level": "INFO",
  "request_id": "295968f7-2c01-4a6a-ab6c-c1d4bf74d6eb",
  "llm": "gpt-4",
  "tokens": 2500,
  "command": "criar_repositorio_golang_project_template",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 12000,
  "details": {
    "repo": "golang_project_template",
    "url": "https://github.com/tiagonpsilva/golang_project_template",
    "estrutura": ["cmd/","pkg/","internal/","api/","configs/","scripts/","build/","deployments/","iac/","docs/","tests/",".gitignore","README.md"],
    "recomendacoes": ["Use cmd/ para binários","Coloque código compartilhado em pkg/ e privado em internal/","Documentação em docs/","Infraestrutura em iac/","Testes em tests/","Configurações versionadas em configs/"]
  }
}

Resultado

O repositório foi criado automaticamente pelo agente MCPilot, seguindo as melhores práticas de estruturação para projetos em Go. A estrutura recomendada inclui diretórios para binários, código reutilizável, documentação, infraestrutura como código, testes automatizados e arquivos essenciais como README e .gitignore. Isso acelera o início de novos projetos, padroniza o ambiente de desenvolvimento e facilita o onboarding de novos membros. O link do repositório e a estrutura criada ficam disponíveis para consulta e colaboração imediata.

🏗️ Case 2: Geração de Artefato de Arquitetura com Base no Código

A documentação visual dos fluxos principais de um sistema é fundamental para onboarding, manutenção e comunicação entre times. Utilizando IA, é possível gerar diagramas de sequência automaticamente a partir da análise do código e de prompts em linguagem natural, acelerando a criação de artefatos arquiteturais.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant 👤 Usuário
    participant 🤖 MCPilot
    participant 🧠 LLM
    participant 📄 Artefato
    👤 Usuário->>🤖 MCPilot: Solicita diagrama de sequência dos fluxos principais
    🤖 MCPilot->>🧠 LLM: Analisa código e gera diagrama
    🧠 LLM-->>📄 Artefato: Diagrama de sequência gerado
    📄 Artefato-->>👤 Usuário: Exibe diagrama pronto para documentação

Prompt

📝 Prompt enviado:

quero que vc leia o repositório novamente e gere um diagrama de sequencia com o detalhamento dos principais fluxos

🤖 Resposta da IA:

Vou gerar um diagrama de sequência detalhando os principais fluxos do projeto "calculadora-ganho-capital", com base na leitura dos arquivos principais do repositório.

(Diagrama gerado como código no padrão Mermaid)

 sequenceDiagram
    participant Usuário
    participant main.py
    participant CalculadoraGanhoCapital
    participant Arquivo_JSON

    Usuário->>main.py: Executa python main.py <arquivo.json>
    main.py->>Arquivo_JSON: Lê operações do arquivo JSON
    main.py->>CalculadoraGanhoCapital: Instancia classe CalculadoraGanhoCapital
    loop Para cada operação
        main.py->>CalculadoraGanhoCapital: processar_operacao(operação)
        CalculadoraGanhoCapital-->>main.py: Retorna imposto calculado
    end
    main.py->>Usuário: Exibe resultado (impostos por operação)

    alt Processamento de arquivo de operações
        main.py->>CalculadoraGanhoCapital: processar_arquivo(<arquivo.json>)
        CalculadoraGanhoCapital->>Arquivo_JSON: Lê lista de operações
        loop Para cada operação
            CalculadoraGanhoCapital->>CalculadoraGanhoCapital: processar_operacao(operação)
        end
        CalculadoraGanhoCapital-->>main.py: Retorna lista de impostos
        main.py->>Usuário: Exibe resultados consolidados
    end

Log Registrado

{
  "timestamp": "2025-05-28T00:35:00.0NZ",
  "level": "INFO",
  "request_id": "12345678-aaaa-bbbb-cccc-1234567890ab",
  "llm": "gpt-4",
  "tokens": 900,
  "command": "gerar_diagrama_sequencia",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 3500,
  "details": {
    "mermaid": "sequenceDiagram... (conteúdo do diagrama)"
  }
}

Resultado

No 🏗️ Case 2, a IA gerou automaticamente um diagrama de sequência detalhando os principais fluxos do projeto, a partir da análise do código-fonte. Esse artefato visual pode ser utilizado em documentações técnicas, apresentações, revisões de arquitetura e onboarding de novos desenvolvedores, promovendo alinhamento e clareza sobre o funcionamento do sistema. O diagrama pode ser facilmente incorporado em wikis ou exportado para apresentações.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant Usuário
    participant main.py
    participant CalculadoraGanhoCapital
    participant Arquivo_JSON

    Usuário->>main.py: Executa python main.py <arquivo.json>
    main.py->>Arquivo_JSON: Lê operações do arquivo JSON
    main.py->>CalculadoraGanhoCapital: Instancia classe CalculadoraGanhoCapital
    loop Para cada operação
        main.py->>CalculadoraGanhoCapital: processar_operacao(operação)
        CalculadoraGanhoCapital-->>main.py: Retorna imposto calculado
    end
    main.py->>Usuário: Exibe resultado (impostos por operação)

    alt Processamento de arquivo de operações
        main.py->>CalculadoraGanhoCapital: processar_arquivo(<arquivo.json>)
        CalculadoraGanhoCapital->>Arquivo_JSON: Lê lista de operações
        loop Para cada operação
            CalculadoraGanhoCapital->>CalculadoraGanhoCapital: processar_operacao(operação)
        end
        CalculadoraGanhoCapital-->>main.py: Retorna lista de impostos
        main.py->>Usuário: Exibe resultados consolidados
    end

📝 Case 3: Criação de Issues de Melhoria via IA

Ao analisar um projeto Python de cálculo de imposto sobre ganho de capital, identificou-se a necessidade de melhorias em segurança, observabilidade, escalabilidade, boas práticas e desempenho. Utilizando o agente Github MCPilot, foi possível gerar issues automaticamente, promovendo governança e rastreabilidade.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant 👤 Usuário
    participant 🤖 MCPilot
    participant 🐙 GithubAPI
    participant 📝 Issues
    👤 Usuário->>🤖 MCPilot: Solicita melhorias via prompt
    🤖 MCPilot->>🐙 GithubAPI: Cria issues
    🐙 GithubAPI-->>📝 Issues: Issues criadas
    📝 Issues-->>👤 Usuário: Visualiza issues no Github

Prompt

📝 Prompt enviado:

Gere cinco issues no repositório com melhorias de:

• Segurança
• Observabilidade
• Escalabilidade
• Boas Práticas
• Desempenho

🤖 Resposta da IA:

Cinco issues de melhorias foram criadas no repositório "calculadora-ganho-capital", cada uma focada em um aspecto essencial:

1. Segurança: Melhoria de Segurança: Validação de entradas e tratamento de dados sensíveis Implementar validação rigorosa das entradas do usuário e garantir tratamento seguro de dados sensíveis para evitar vulnerabilidades como injection e vazamento de informações.

2. Observabilidade: Melhoria de Observabilidade: Logging estruturado e métricas Adicionar logging estruturado e coleta de métricas para monitorar o funcionamento do sistema, facilitando a detecção de erros e análise de uso.

3. Escalabilidade: Melhoria de Escalabilidade: Suporte a múltiplos arquivos e processamento paralelo Permitir o processamento de múltiplos arquivos de operações em paralelo, otimizando o desempenho para grandes volumes de dados.

4. Boas Práticas: Boas Práticas: Padronização de código e documentação Revisar o código para garantir padronização (PEP8), adicionar docstrings e melhorar a documentação para facilitar a manutenção e colaboração.

5. Desempenho: Desempenho: Otimização de cálculos e uso de memória Analisar e otimizar os algoritmos de cálculo de imposto para reduzir o tempo de execução e o consumo de memória, especialmente em grandes volumes de operações.

Todas as issues já estão abertas e disponíveis para acompanhamento no GitHub! Se quiser editar, priorizar ou detalhar alguma delas, é só avisar.

Log Registrado

{
  "timestamp": "2025-05-28T00:41:19.3NZ",
  "level": "INFO",
  "request_id": "189303d3-1c7e-44a7-809d-8f0773be0a1e",
  "llm": "gpt-4",
  "tokens": 1800,
  "command": "criar_issues_melhorias",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 4000,
  "details": {
    "issues": [
      {"titulo": "Melhoria de Segurança: Validação de entradas e tratamento de dados sensíveis", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/issues/7"},
      {"titulo": "Melhoria de Observabilidade: Logging estruturado e métricas", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/issues/8"},
      {"titulo": "Melhoria de Escalabilidade: Suporte a múltiplos arquivos e processamento paralelo", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/issues/9"},
      {"titulo": "Boas Práticas: Padronização de código e documentação", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/issues/10"},
      {"titulo": "Desempenho: Otimização de cálculos e uso de memória", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/issues/11"}
    ]
  }
}

Resultado

No 📝 Case 3, o agente MCPilot criou automaticamente cinco issues de melhoria no repositório, cada uma abordando um aspecto fundamental: segurança, observabilidade, escalabilidade, boas práticas e desempenho. Isso garante rastreabilidade das demandas de evolução, facilita o acompanhamento pelo time e promove uma cultura de melhoria contínua. As issues já estão disponíveis para priorização, detalhamento e atribuição no GitHub.

🔀 Case 4: Fluxo Completo de Pull Request com IA

A automação do fluxo de pull request (PR) com IA permite criar, revisar e aprovar mudanças de forma colaborativa e auditável, integrando logs e sugestões de melhoria.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant 👤 Dev
    participant 🤖 MCPilot
    participant 🐙 Github
    participant 👀 Reviewer
    👤 Dev->>🤖 MCPilot: Solicita criação de PR
    🤖 MCPilot->>🐙 Github: Cria PR
    🐙 Github-->>👤 Dev: Retorna link do PR
    👀 Reviewer->>🤖 MCPilot: Solicita revisão automática
    🤖 MCPilot->>🐙 Github: Adiciona comentários e aprovações
    🐙 Github-->>👀 Reviewer: Retorna status

Prompt

📝 Prompt enviado:

Agora quero que vc abra uma PR para implementação de melhorias de observabilidade

🤖 Resposta da IA:

Para abrir uma Pull Request (PR) de melhorias de observabilidade, preciso seguir o fluxo Git-flow:

1. Criar um novo branch a partir do main (ou branch padrão).
2. Sugerir um nome para o branch (exemplo: feature/observabilidade-logging).
3. Você pode fazer commits diretamente ou me informar os arquivos/códigos a serem alterados.
4. Subir as alterações e abrir a PR com descrição clara.

(Aguardando confirmação do usuário)

📝 Prompt enviado:

Pode criar a nova branch vazia. Use o nome de branch sugerida e partir da main. Não se esqueça dos logs

🤖 Resposta da IA:

Branch feature/observabilidade-logging criada com sucesso a partir da main, pronta para implementação das melhorias de observabilidade.

O log estruturado dessa operação foi gravado corretamente.

Houve uma instabilidade ao tentar abrir a Pull Request automaticamente. Deseja que eu tente novamente abrir a PR agora, ou prefere abrir manualmente pelo GitHub? Se quiser que eu tente novamente, é só confirmar!

📝 Prompt enviado:

Consulte as PRs abertas para este repositório

🤖 Resposta da IA:

Atualmente há uma Pull Request aberta para melhorias de observabilidade no repositório "calculadora-ganho-capital":

• Título: feat(observabilidade): logging estruturado, métricas de execução e configuração dinâmica do nível de log
• Descrição: Implementa logging estruturado (JSON) em todos os pontos-chave do fluxo, métricas de execução (tempo, quantidade de operações, erros) e configuração dinâmica do nível de log via argumento de linha de comando (--log-level).
• Autor: tiagonpsilva
• Status: Aberta
• Link: Ver PR no GitHub

📝 Prompt enviado:

Quero o log desta operacao

🤖 Resposta da IA:

O log estruturado da operação de consulta das PRs abertas foi gravado com sucesso.

Se quiser visualizar o conteúdo do log ou registrar mais alguma operação, é só pedir! Todas as próximas interações MCP também serão registradas automaticamente conforme as regras do agente.

📝 Prompt enviado:

Faça um code review das mudanças propostas nesta PR (nao se esqueça de logar)

🤖 Resposta da IA:

Code review realizado e comentário publicado na PR #6.

O log estruturado desta operação foi gravado com sucesso, incluindo:

• Pontos positivos da implementação
• Sugestões de melhoria
• Link direto para o comentário do review: https://github.com/tiagonpsilva/calculadora-ganho-capital/pull/6#pullrequestreview-2873180056

Se quiser visualizar o conteúdo do log, revisar outro PR ou realizar mais alguma ação, é só pedir!

📝 Prompt enviado:

Liste o comentário feito no code review e faça um log da operação

🤖 Resposta da IA:

Aqui estão os principais comentários feitos no code review da PR #6:

1. processar_compra: Atualize a docstring para incluir o parâmetro logger.
2. processar_venda: Atualize a docstring para incluir o parâmetro logger.
3. processar_operacao: Atualize a docstring para incluir o parâmetro logger.
4. calcular_impostos: Atualize a docstring para incluir o parâmetro logger.
5. processar_arquivo: Atualize a docstring para incluir o parâmetro logger.
6. test_quantidade_para_venda: Troque assertRaises(Exception) por assertRaises(ValueError) para maior precisão.

O log estruturado desta operação foi gravado com sucesso, incluindo todos os comentários listados.

Se quiser visualizar o conteúdo do log, revisar outro PR ou realizar mais alguma ação, é só pedir!

Log Registrado

Criação de branch para observabilidade

{
  "timestamp": "2025-05-28T00:46:26.3NZ",
  "level": "INFO",
  "request_id": "a58ac7e1-6dcd-4834-9db2-2a703add6223",
  "llm": "gpt-4",
  "tokens": 500,
  "command": "criar_branch_observabilidade",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 1200,
  "details": {
    "branch": "feature/observabilidade-logging",
    "base": "main",
    "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/tree/feature/observabilidade-logging"
  }
}

Consulta de PRs abertas

{
  "timestamp": "2025-05-28T00:48:55.3NZ",
  "level": "INFO",
  "request_id": "d2eb8d2c-440a-4dd3-bb54-d610406f6ada",
  "llm": "gpt-4",
  "tokens": 400,
  "command": "consultar_prs_abertas",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 900,
  "details": {
    "prs": [
      {"numero": 6, "titulo": "feat(observabilidade): logging estruturado, métricas de execução e configuração dinâmica do nível de log", "autor": "tiagonpsilva", "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/pull/6"}
    ]
  }
}

Code review realizado

{
  "timestamp": "2025-05-28T00:50:04.3NZ",
  "level": "INFO",
  "request_id": "ea549e91-9120-4536-91dd-eedf75f59fc0",
  "llm": "gpt-4",
  "tokens": 1200,
  "command": "code_review_pr_6",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 27000,
  "details": {
    "pr": 6,
    "comentario_url": "https://github.com/tiagonpsilva/calculadora-ganho-capital/pull/6#pullrequestreview-2873180056",
    "pontos_positivos": [
      "Logging estruturado em JSON",
      "Métricas de execução",
      "Configuração dinâmica do nível de log",
      "Logger propagado para métodos principais",
      "Teste para venda maior que disponível"
    ],
    "sugestoes": [
      "Logs de auditoria para exceções",
      "Logs de warning para operações incomuns",
      "Exemplo do parâmetro --log-level no README",
      "Padronizar mensagens de log"
    ]
  }
}

Listagem de comentários do code review

{
  "timestamp": "2025-05-28T00:52:52.3NZ",
  "level": "INFO",
  "request_id": "8589e71e-0bb4-49c7-a83f-c129acdac991",
  "llm": "gpt-4",
  "tokens": 800,
  "command": "listar_comentarios_code_review_pr_6",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 2500,
  "details": {
    "comentarios": [
      {"autor": "gemini-code-assist[bot]", "trecho": "processar_compra", "comentario": "Atualize a docstring para incluir o parâmetro logger."},
      {"autor": "gemini-code-assist[bot]", "trecho": "processar_venda", "comentario": "Atualize a docstring para incluir o parâmetro logger."},
      {"autor": "gemini-code-assist[bot]", "trecho": "processar_operacao", "comentario": "Atualize a docstring para incluir o parâmetro logger."},
      {"autor": "gemini-code-assist[bot]", "trecho": "calcular_impostos", "comentario": "Atualize a docstring para incluir o parâmetro logger."},
      {"autor": "gemini-code-assist[bot]", "trecho": "processar_arquivo", "comentario": "Atualize a docstring para incluir o parâmetro logger."},
      {"autor": "gemini-code-assist[bot]", "trecho": "test_quantidade_para_venda", "comentario": "Troque assertRaises(Exception) por assertRaises(ValueError) para maior precisão."}
    ]
  }
}

Resultado

No 🔀 Case 4, o fluxo completo de Pull Request foi automatizado: desde a criação do branch, abertura da PR, consulta das PRs abertas, até a realização de code review com comentários detalhados. O resultado é um processo auditável, colaborativo e transparente, com logs estruturados de cada etapa. O time pode acompanhar o histórico de revisões, sugestões e aprovações diretamente no GitHub, acelerando o ciclo de feedback e a qualidade do código entregue.

📊 Case 5: Observabilidade — Logging Estruturado e Métricas

Para garantir rastreabilidade e facilitar auditoria, o agente MCPilot implementa logging estruturado (JSON) em todas as operações, incluindo métricas de execução, erros e sucesso. Isso permite análises detalhadas e exportação para ferramentas de BI.

%%{init: { "themeVariables": { "fontFamily": "Arial", "fontSize": "10px" } }}%%
sequenceDiagram
    participant 👤 Usuário
    participant 🤖 MCPilot
    participant 📄 LogFile
    👤 Usuário->>🤖 MCPilot: Executa comando MCP
    🤖 MCPilot->>📄 LogFile: Gera log estruturado
    📄 LogFile-->>👤 Usuário: Log disponível para análise/exportação

Prompt

📝 Prompt enviado:

quero que vc leia a estrutura de logs e gere alguns insights, com base nas informações existentes lá

🤖 Resposta da IA:

Aqui estão alguns insights baseados na análise dos logs estruturados recentes:

---

Fluxo de Trabalho Moderno e Automatizado

• O uso de comandos como criação de branch, abertura de PR, code review automatizado e geração de issues mostra um fluxo de trabalho alinhado com DevOps e GitHub Actions.
• O padrão de logs estruturados facilita auditoria, rastreabilidade e integração com ferramentas de observabilidade.

Foco em Qualidade e Melhoria Contínua

• Foram criadas issues para Segurança, Observabilidade, Escalabilidade, Boas Práticas e Desempenho, indicando preocupação com a evolução contínua do projeto.
• O code review destaca pontos positivos e sugestões de melhoria, promovendo cultura de feedback construtivo.

Automação e Padronização

• Logs detalham comandos, parâmetros, resultados e links, permitindo fácil rastreamento de cada ação.
• Estruturas de repositório seguem padrões de mercado, com separação clara de responsabilidades.

Observabilidade e Transparência

• Todas as operações relevantes são logadas, incluindo sucesso, falha, duração e detalhes.
• O uso de logging estruturado em JSON e métricas de execução nas PRs mostra maturidade em observabilidade.

Sugestões para Evolução

• Manter a documentação dos parâmetros e exemplos de uso sempre atualizada.
• Adotar logs de warning e auditoria para eventos críticos, além dos logs de erro.
• Utilizar os dados de duração e tokens dos logs para identificar gargalos ou oportunidades de otimização.

📝 Prompt enviado:

Gere Métricas e KPIs

🤖 Resposta da IA:

Aqui estão algumas métricas e KPIs extraídos dos últimos 100 registros do log estruturado:

---

KPIs Gerais

• Total de operações registradas: 11
• Operações bem-sucedidas: 11 (100%)
• Principais comandos executados: criação de issues, criação de branch e PR, consulta de repositórios e PRs, code review e comentários, criação de repositório template

Métricas de Performance

• Tempo médio de execução das operações: de 1 ms (teste) até 27.000 ms (code review detalhado)
• Operações comuns: entre 900 ms e 4.000 ms

Engajamento e Automação

• Issues criadas automaticamente: 5
• Branches criadas via automação: 1
• Pull Requests abertas via automação: 1
• Code reviews automatizados: 1
• Repositórios criados via automação: 1

Qualidade e Colaboração

• Sugestões de melhoria em code review: padronização de logs, inclusão de exemplos no README, auditoria e warnings em logs, melhoria de docstrings e precisão em testes
• Colaboração registrada: comentários detalhados em PRs, feedbacks construtivos para evolução do código

Recomendações para próximos KPIs

• Taxa de aprovação de PRs
• Tempo médio para merge de PR
• Tempo entre criação de issue e fechamento
• Cobertura de testes automatizados
• Evolução do número de repositórios e automações

Log Registrado

Exemplo: Listagem de repositórios

{
  "timestamp": "2025-05-28T00:30:25.3NZ",
  "level": "INFO",
  "request_id": "8ce8f08f-d8c1-4664-a134-51139c3a4c36",
  "llm": "gpt-4",
  "tokens": 2000,
  "command": "listar_repositorios",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 1200,
  "details": {
    "repositorios": ["genai-mcp-client-claude-github","treinamento-modern-data-stack-01","go-lang-samples","software-architecture-foundations","genai-langchain-tutorial","tiagonpsilva","databricks-certified-data-engineer-associate","genai-claude-code-best-practices","knowledge-base","system-design-interview"]
  }
}

Exemplo: Consulta de informações de repositório

{
  "timestamp": "2025-05-28T00:32:46.3NZ",
  "level": "INFO",
  "request_id": "aa5ea466-9732-4b37-ab2d-7305791f3569",
  "llm": "gpt-4",
  "tokens": 1200,
  "command": "consultar_info_repositorio",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 800,
  "details": {
    "repositorio": {
      "nome": "calculadora-ganho-capital",
      "url": "https://github.com/tiagonpsilva/calculadora-ganho-capital",
      "linguagem": "Python",
      "privado": false,
      "forks": 0,
      "issues_abertas": 6,
      "estrelas": 0,
      "tamanho_kb": 191,
      "criado_em": "2025-03-16T20:33:16Z",
      "atualizado_em": "2025-05-27T22:10:04Z",
      "permissoes": {"admin": true, "push": true, "pull": true}
    }
  }
}

Exemplo: Teste de logging

{
  "timestamp": "2024-06-07T10:00:00.000Z",
  "level": "INFO",
  "request_id": "00000000-0000-4000-8000-000000000000",
  "llm": "gpt-4",
  "tokens": 1,
  "command": "teste_log",
  "user": "tiagonpsilva",
  "result": "success",
  "duration_ms": 1,
  "details": {}
}

Resultado

No 📊 Case 5, a análise dos logs estruturados permitiu extrair métricas, KPIs e insights sobre o uso do agente MCPilot e a automação dos fluxos de engenharia. O time pode utilizar esses dados para monitorar produtividade, identificar gargalos, auditar operações e alimentar dashboards de BI. O padrão de logging adotado facilita a integração com ferramentas de observabilidade e a geração de relatórios personalizados.

🎯 Conclusão

A jornada apresentada neste artigo mostra que a integração de IA com ferramentas já consolidadas no ecossistema de desenvolvimento, como IDEs modernas, GitHub e automação via agentes, não é apenas possível, mas altamente recomendada para times que buscam produtividade, rastreabilidade e governança.

O Github MCPilot, ao unir o poder do protocolo MCP, a segurança e portabilidade do Docker e a flexibilidade das Cursor Rules, representa um novo patamar de automação para times de engenharia. Ele transforma tarefas repetitivas em fluxos inteligentes, auditáveis e seguros, permitindo que desenvolvedores foquem no que realmente importa: entregar valor.

Além disso, a experiência de uso do agente, com saudação personalizada, menu interativo, logging estruturado e validação de ambiente, eleva o padrão de usabilidade e confiança em automações.

Principais aprendizados:

• A automação inteligente reduz erros, acelera entregas e facilita o onboarding de novos membros.
• O uso de protocolos abertos e ferramentas padronizadas (como MCP e Docker) garante portabilidade e segurança.
• O registro estruturado de logs e métricas permite auditoria, melhoria contínua e integrações.
• A experiência do desenvolvedor é central: interfaces amigáveis, feedbacks claros e proatividade fazem toda a diferença.

Se você quiser testar essa abordagem, basta seguir os passos do Github MCPilot. Fique à vontade para ajustá-lo para o seu caso e usar como base para outros projetos.

Obrigado pela leitura!

📚 Referências

• https://www.anthropic.com/news/model-context-protocol
• https://docs.cursor.com/get-started/introduction
• https://docs.cursor.com/context/rules
• https://www.docker.com/blog/introducing-docker-mcp-catalog-and-toolkit/