MCP Jenkins Intelligence

Plataforma de inteligência de pipelines Jenkins com interface em linguagem natural, alimentada por IA. Oferece análise abrangente de pipelines, previsão de falhas, sugestões de otimização e reconstrução automatizada de Jenkinsfile utilizando integração com Model Context Protocol (MCP).

GitHub

Experimente este MCPPatrocinado

Documentação

MCP Jenkins Intelligence

A Plataforma de Inteligência Jenkins
Transforme suas operações Jenkins com interfaces de linguagem natural alimentadas por IA e análise abrangente de pipelines.

Início Rápido (Distribuição Binária)

Prefere um binário pronto para uso? Baixe a versão mais recente e comece a usar o MCP Jenkins Intelligence em segundos!

Download e Instalação

# Option 1: Use the installer script (recommended)
curl -fsSL https://raw.githubusercontent.com/heniv96/mcp-jenkins-intelligence/main/install.sh | bash

# Option 2: Manual download
# Download from: https://github.com/heniv96/mcp-jenkins-intelligence/releases/latest
# Choose the appropriate binary for your platform:
# - mcp-jenkins-server-macos-arm64 (macOS Apple Silicon)
# - mcp-jenkins-server-linux-amd64 (Linux AMD64)
# Make executable: chmod +x mcp-jenkins-server-<platform>

Configuração do MCP

Adicione à configuração do seu cliente MCP (Cursor/VSCode):

{
  "mcpServers": {
    "mcp-jenkins-intelligence": {
      "command": "/path/to/mcp-jenkins-server",
      "args": [],
      "env": {
        "JENKINS_URL": "https://your-jenkins-url",
        "JENKINS_USERNAME": "your-username", 
        "JENKINS_TOKEN": "your-token"
      }
    }
  }
}

É isso! Sem instalação de Python, sem dependências — basta baixar e executar!

Visão Geral

O MCP Jenkins Intelligence é uma solução abrangente de Model Context Protocol (MCP) projetada para equipes DevOps profissionais. Ele fornece interfaces de linguagem natural para operações complexas de pipelines Jenkins, permitindo que as equipes monitorem, analisem e otimizem seus fluxos de trabalho de CI/CD por meio de conversas alimentadas por IA no VSCode e no Cursor.

Principais Recursos

Análise Inteligente de Pipelines

Monitoramento em Tempo Real: Status de pipelines ao vivo, métricas de saúde e análises de desempenho
Insights com IA: Consultas em linguagem natural para análise complexa de pipelines
Análise de Falhas: Análise aprofundada de falhas em pipelines com análise inteligente de causa raiz
Otimização de Desempenho: Sugestões automatizadas para melhorar tempos de build e taxas de sucesso
Análises Avançadas: Relatórios abrangentes e comparações de desempenho
Detecção de Anomalias: Detecção com IA de padrões incomuns de comportamento em pipelines

Capacidades Avançadas de IA

Processamento de Linguagem Natural: Interface conversacional para operações DevOps complexas
Diagnóstico Inteligente: Análise de saúde de pipelines e orientação de solução de problemas com IA
Prompts Contextuais: Sugestões inteligentes de prompts para diferentes cenários de análise
Relatórios Automatizados: Identificação proativa de problemas e oportunidades de otimização

Segurança e Conformidade Empresarial

Suporte a Múltiplas Autenticações: Integração com Jenkins padrão e Azure AD
Comunicação Segura: Criptografia TLS para todas as comunicações com a API Jenkins
Registro de Auditoria: Trilhas de auditoria abrangentes para todas as operações de pipelines
Privilégio Mínimo: Seguro por design com padrões de acesso de menor privilégio
Proteção de Dados de Nível Empresarial: Mais de 19 padrões de proteção para anonimização completa de dados
Anonimização Completa: Nomes de pipelines, nomes de clusters, nomes de pastas, nomes de aplicativos, nomes de branches, nomes de organizações, nomes de repositórios e nomes de arquivos de código são todos protegidos
Segurança Baseada em Hash: Dados sensíveis são substituídos por hashes seguros antes da comunicação com IA
Execução Local: Todo o processamento de dados acontece localmente — nenhum dado sai do seu ambiente
Proteção Recursiva: Funciona em estruturas de dados aninhadas e objetos complexos
Auditoria de Controle de Acesso: Análise abrangente de permissões e controle de acesso

Análises e Relatórios Avançados

Relatórios Abrangentes: Gere relatórios detalhados com métricas e insights
Comparações de Desempenho: Compare o desempenho de pipelines entre equipes e ambientes
Análise de Tendências: Análise de tendências de desempenho e confiabilidade de longo prazo

Recursos Avançados de IA

Detecção de Anomalias: Detecção com IA de padrões incomuns de comportamento em pipelines
Insights Abrangentes: Insights e recomendações gerados por IA

Otimização de Desempenho

Análise de Tempo de Build: Análise detalhada e sugestões de otimização para tempos de build

Implantação e Distribuição

Múltiplas Opções de Implantação: Configuração de desenvolvimento ou implantação de produção
Suporte Multiplataforma: Funciona em macOS, Linux e Windows
Configuração Fácil: Configuração simples com variáveis de ambiente ou configuração MCP

Arquitetura

Integração com o Protocolo MCP

O diagrama a seguir mostra como o MCP Jenkins Intelligence se integra ao VSCode e ao Cursor AI por meio do Model Context Protocol:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   VSCode/       │    │   MCP Protocol  │    │   Jenkins       │
│   Cursor AI     │◄──►│                 │◄──►│   Intelligence  │
│                 │    │                 │    │   Server        │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                                │
                                ▼
                    ┌─────────────────────────────────────────┐
                    │            Jenkins API                  │
                    └─────────────────────────────────────────┘
                                │
                                ▼
        ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
        │   AI Analysis   │    │   Core Tools    │    │   MCP Resources │
        │   Engine        │    │   (30 tools)    │    │   & Prompts     │
        └─────────────────┘    └─────────────────┘    └─────────────────┘
                │                        │                        │
                ▼                        ▼                        ▼
        ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
        │ • Health        │    │ • List          │    │ • Status        │
        │   Analysis      │    │ • Details       │    │   Resource      │
        │ • Failure       │    │ • Builds        │    │ • Summary       │
        │   Analysis      │    │ • Configure     │    │   Resource      │
        │ • AI Queries    │    │ • Test          │    │ • Dashboard     │
        │ • Metrics       │    │ • Questions     │    │   Resource      │
        │ • Dependencies  │    │ • Trigger       │    │ • Logs          │
        │ • Trends        │    │ • Stop          │    │   Resource      │
        │ • Security      │    │ • Enable/Dis    │    │ • Health        │
        │ • Export        │    │ • Config        │    │   Resource      │
        │ • Optimize      │    │ • Predict       │    │ • Analysis      │
        │                 │    │ • Suggest       │    │   Prompts       │
        └─────────────────┘    └─────────────────┘    └─────────────────┘

Arquitetura Modular

A arquitetura interna segue um design modular e limpo com separação de responsabilidades:

┌─────────────────────────────────────────────────────────────────────────┐
│                              MCP Layer                                  │
├─────────────────┬─────────────────┬─────────────────────────────────────┤
│  FastMCP Server │  Tool Registry  │  Request Router                     │
└─────────────────┴─────────────────┴─────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                           Modular Services                              │
├─────────────┬─────────────┬─────────────┬─────────────┬─────────────────┤
│   Models    │  Services   │  Resources  │   Prompts   │                 │
├─────────────┼─────────────┼─────────────┼─────────────┼─────────────────┤
│ • Pipeline  │ • Jenkins   │ • Status    │ • Analysis  │                 │
│ • Build     │ • Core      │ • Summary   │ • Failure   │                 │
│ • Health    │ • Control   │ • Dashboard │ • Optimize  │                 │
│ • Failure   │ • Monitor   │ • Logs      │ • Security  │                 │
│ • Query     │ • AI        │ • Health    │             │                 │
│             │ • Security  │             │             │                 │
└─────────────┴─────────────┴─────────────┴─────────────┴─────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                         Tool Categories                                 │
├─────────────────┬─────────────────┬─────────────────┬─────────────────┤
│  Core Tools (9) │  Control Tools  │  Monitoring (4) │  AI Tools (5)   │
│                 │     (4)         │                 │                 │
├─────────────────┼─────────────────┼─────────────────┼─────────────────┤
│ • list_pipelines│ • trigger_build │ • get_metrics   │ • Predict       │
│ • get_details   │ • stop_build    │ • dependencies  │   Failure       │
│ • get_builds    │ • enable_disable│ • monitor_queue │ • Suggest       │
│ • ask_questions │ • get_config    │ • analyze_trends│   Optimize      │
│ • configure_    │                 │                 │ • Anomaly       │
│   jenkins       │                 │                 │   Detection     │
│ • test_         │                 │                 │ • AI            │
│   connection    │                 │                 │   Insights      │
│ • analyze_      │                 │                 │ • Retry         │
│   health        │                 │                 │   Logic         │
│ • analyze_      │                 │                 │                 │
│   failure       │                 │                 │                 │
│ • get_server_   │                 │                 │                 │
│   info          │                 │                 │                 │
└─────────────────┴─────────────────┴─────────────────┴─────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                    Additional Tool Categories                           │
├─────────────┬─────────────┬─────────────┬─────────────────────────────┤
│  Security   │ Jenkinsfile │  Analytics  │  Performance                │
│     (2)     │     (3)     │     (2)     │      (1)                    │
├─────────────┼─────────────┼─────────────┼─────────────────────────────┤
│ • scan_     │ • get_      │ • generate_ │ • analyze_                  │
│   security  │   jenkinsfile│   report   │   build_time                │
│             │ • reconstruct│ • compare_ │                             │
│             │ • suggest_  │   performance│                             │
│             │   improvements│             │                             │
└─────────────┴─────────────┴─────────────┴─────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                    MCP Resources & Prompts                             │
├─────────────────────────┬─────────────────────────────────────────────┤
│  Resources (5)          │  Prompts (4)                                │
├─────────────────────────┼─────────────────────────────────────────────┤
│ • pipeline://status     │ • analyze_pipeline_prompt                   │
│ • pipeline://{name}/    │ • failure_analysis_prompt                   │
│   summary               │ • optimization_prompt                       │
│ • pipeline://dashboard  │ • security_audit_prompt                     │
│ • pipeline://{name}/    │                                             │
│   logs                  │                                             │
│ • pipeline://health     │                                             │
└─────────────────────────┴─────────────────────────────────────────────┘

Estrutura de Diretórios

mcp-jenkins-intelligence/
├── server.py                 # Main MCP server (679 lines)
├── models/
│   ├── __init__.py
│   └── pipeline.py          # Pydantic models
├── services/
│   ├── __init__.py
│   ├── jenkins_service.py   # Jenkins API wrapper
│   ├── core_tools.py        # Core pipeline tools
│   ├── monitoring_tools.py  # Monitoring & analytics
│   ├── ai_tools.py          # AI intelligence tools
│   ├── security_tools.py    # Security & compliance
│   ├── advanced_ai_tools.py # Advanced AI features
│   ├── advanced_security_tools.py # Advanced security tools
│   ├── analytics_tools.py   # Analytics & reporting
│   ├── performance_tools.py # Performance optimization
│   ├── execution_analysis_service.py # Execution analysis
│   └── jenkinsfile_retrieval_service.py # Jenkinsfile management
├── resources/
│   ├── __init__.py
│   └── pipeline_resources.py # MCP resources
├── prompts/
│   ├── __init__.py
│   └── pipeline_prompts.py  # MCP prompts
├── config/
│   └── settings.py          # Configuration management
├── utils/
│   ├── __init__.py
│   └── helpers.py           # Helper functions
├── manuals/
│   ├── configuration/
│   │   └── README.md        # Configuration guide
│   ├── examples/
│   │   └── mcp-config-standalone.json # Example configuration
│   ├── quick-start/
│   │   └── README.md        # Quick start guide
│   └── troubleshooting/
│       └── README.md        # Troubleshooting guide
├── dist/                    # Built binaries (GitHub Releases)
│   ├── mcp-jenkins-server-macos-arm64    # macOS Apple Silicon binary
│   └── mcp-jenkins-server-linux-amd64    # Linux AMD64 binary
├── install.sh               # Automated installer script
├── Makefile                 # Build automation
├── build.sh                 # Build test script
├── requirements.txt         # Python dependencies
├── pyproject.toml          # Project configuration
├── LICENSE                 # MIT License
└── README.md              # This file

Instalação e Configuração

Pré-requisitos

Python 3.8+ (para configuração de desenvolvimento)
Servidor Jenkins com acesso à API
Cliente MCP (VSCode com extensão MCP ou Cursor)

Instalação Binária (Recomendada)

Baixe o binário para sua plataforma:

# macOS (Apple Silicon)
curl -L -o mcp-jenkins-server https://github.com/heniv96/mcp-jenkins-intelligence/releases/latest/download/mcp-jenkins-server-macos-arm64

# Linux (AMD64)
curl -L -o mcp-jenkins-server https://github.com/heniv96/mcp-jenkins-intelligence/releases/latest/download/mcp-jenkins-server-linux-amd64

Torne-o executável:
```
chmod +x mcp-jenkins-server
```
Configure seu cliente MCP (veja a seção de Configuração do MCP acima)

Configuração de Desenvolvimento

Clone o repositório:

git clone https://github.com/heniv96/mcp-jenkins-intelligence.git
cd mcp-jenkins-intelligence

Instale as dependências:
```
pip install -r requirements.txt
```

Defina as variáveis de ambiente:

export JENKINS_URL="https://your-jenkins-url"
export JENKINS_USERNAME="your-username"
export JENKINS_TOKEN="your-token"

Execute o servidor:
```
python server.py
```

Configuração

Variáveis de Ambiente

Variável	Descrição	Obrigatória	Padrão
`JENKINS_URL`	URL do servidor Jenkins	Sim	-
`JENKINS_USERNAME`	Nome de usuário Jenkins	Sim	-
`JENKINS_TOKEN`	Token da API Jenkins	Sim	-
`MCP_SERVER_PORT`	Porta do servidor MCP	Não	8000

Configuração do Cliente MCP

Configuração do VSCode

Adicione ao seu settings.json:

{
  "mcp.servers": {
    "mcp-jenkins-intelligence": {
      "command": "/path/to/mcp-jenkins-server",
      "args": [],
      "env": {
        "JENKINS_URL": "https://your-jenkins-url",
        "JENKINS_USERNAME": "your-username",
        "JENKINS_TOKEN": "your-token"
      }
    }
  }
}

Configuração do Cursor

Adicione ao seu mcp.json:

{
  "mcpServers": {
    "mcp-jenkins-intelligence": {
      "command": "/path/to/mcp-jenkins-server",
      "args": [],
      "env": {
        "JENKINS_URL": "https://your-jenkins-url",
        "JENKINS_USERNAME": "your-username",
        "JENKINS_TOKEN": "your-token"
      }
    }
  }
}

Uso

Comandos Básicos

Uma vez configurado, você pode interagir com o Jenkins por meio de linguagem natural:

"Listar todos os pipelines" - Obtenha uma lista de todos os pipelines disponíveis
"Mostre-me a saúde do pipeline X" - Obtenha análise detalhada de saúde
"O que há de errado com o build que falhou?" - Analise falhas de build
"Otimize o tempo de build do pipeline Y" - Obtenha sugestões de otimização
"Gere um relatório da semana passada" - Crie relatórios abrangentes

Recursos Avançados

Análise com IA: Faça perguntas complexas sobre o desempenho do seu pipeline
Detecção de Anomalias: Receba alertas sobre comportamentos incomuns em pipelines
Auditoria de Segurança: Análise de segurança abrangente da sua configuração Jenkins
Otimização de Desempenho: Análise detalhada de tempo de build e sugestões

Referência da API

Ferramentas Principais

Ferramenta	Descrição	Parâmetros
`list_pipelines`	Listar todos os pipelines disponíveis	`search` (opcional)
`get_pipeline_details`	Obter informações detalhadas do pipeline	`pipeline_name`
`get_pipeline_builds`	Obter builds recentes de um pipeline	`pipeline_name`, `limit`, `status`
`analyze_pipeline_health`	Analisar saúde e desempenho do pipeline	`pipeline_name`, `period`
`analyze_pipeline_failure`	Analisar falha específica do pipeline	`pipeline_name`, `build_number`
`ask_pipeline_question`	Fazer perguntas em linguagem natural	`question`, `pipeline_names`

Ferramentas de Monitoramento

Ferramenta	Descrição	Parâmetros
`get_pipeline_metrics`	Obter métricas detalhadas do pipeline	`pipeline_name`, `period`
`get_pipeline_dependencies`	Obter dependências do pipeline	`pipeline_name`
`monitor_pipeline_queue`	Monitorar fila de builds do Jenkins	-
`analyze_build_trends`	Analisar tendências de build entre pipelines	`pipeline_names`, `period`

Ferramentas de IA

Ferramenta	Descrição	Parâmetros
`predict_pipeline_failure`	Prever falhas prováveis de pipelines	`pipeline_name`
`suggest_pipeline_optimization`	Obter sugestões de otimização	`pipeline_name`
`detect_pipeline_anomalies`	Detectar comportamento incomum em pipelines	`pipeline_name`, `sensitivity`
`generate_ai_insights`	Gerar insights abrangentes de IA	`pipeline_name`, `insight_type`

Segurança

Proteção de Dados

O MCP Jenkins Intelligence implementa proteção abrangente de dados:

Anonimização Completa: Todos os dados sensíveis são substituídos por hashes seguros
Processamento Local: Todo o processamento de dados acontece localmente
Sem Chamadas Externas: Nenhum dado é enviado a serviços de IA externos
Proteção Recursiva: Funciona em estruturas de dados aninhadas
Auditoria de Controle de Acesso: Análise abrangente de permissões

Padrões de Proteção Suportados

Nomes de pipelines
Nomes de clusters
Nomes de pastas
Nomes de aplicativos
Nomes de branches
Nomes de organizações
Nomes de repositórios
Nomes de arquivos de código
Números de build
Carimbos de data/hora
URLs e caminhos
Informações de usuário
Valores de tokens
Dados de configuração
Entradas de log
Mensagens de erro
Rastreamentos de pilha
Variáveis de ambiente
E muito mais...

Solução de Problemas

Problemas Comuns

Falha de Conexão: Verifique sua URL e credenciais do Jenkins
Permissão Negada: Verifique se seu usuário Jenkins tem as permissões apropriadas
Binário Não Encontrado: Certifique-se de que o binário é executável e está no seu PATH
Cliente MCP Não Respondendo: Verifique sua configuração do MCP

Modo de Depuração

Ative o registro de depuração definindo:

export DEBUG=1

Obtendo Ajuda

Consulte o guia de solução de problemas
Abra uma issue
Revise os exemplos

Contribuindo

Aceitamos contribuições! Consulte nossas diretrizes de contribuição para obter detalhes.

Desenvolvimento

Faça um fork do repositório
Crie um branch de funcionalidade
Faça suas alterações
Adicione testes
Envie um pull request

Compilação

# Install dependencies
pip install -r requirements.txt

# Run tests
python -m pytest

# Build binary
make build

Licença

Este projeto é licenciado sob a Licença MIT — consulte o arquivo LICENSE para obter detalhes.

Agradecimentos

FastMCP - O framework MCP
Jenkins - A plataforma CI/CD
Model Context Protocol - A especificação do protocolo

Registro de Alterações

v1.2.0

Adicionada proteção abrangente de dados e anonimização
Melhorada a distribuição binária com suporte multiplataforma
Recursos de segurança aprimorados e auditoria de controle de acesso
Adicionadas capacidades avançadas de IA e detecção de anomalias
Ferramentas de otimização de desempenho aprimoradas
Adicionados relatórios e análises abrangentes

v1.1.0

Lançamento inicial com funcionalidade MCP principal
Análise e monitoramento básicos de pipelines
Insights e recomendações alimentados por IA

Feito com ❤️ para a comunidade DevOps