Nexus Dashboard

Um servidor abrangente do Model Context Protocol (MCP) para o Cisco Nexus Dashboard, permitindo que agentes de IA como Claude interajam com as APIs do Nexus Dashboard para automação e gerenciamento inteligente de rede.

GitHub

Documentação

Servidor MCP do Nexus Dashboard

Um servidor abrangente de Model Context Protocol (MCP) para o Cisco Nexus Dashboard, permitindo que agentes de IA como o Claude interajam com as APIs do Nexus Dashboard para automação e gerenciamento inteligente de rede.

Recursos

Capacidades Principais

Cobertura Completa de API: Acesso a mais de 638 operações em 5 APIs do Nexus Dashboard
- API Manage (146 endpoints): Fabrics, switches, VLANs, VRFs, redes, interfaces
- API Analyze: Telemetria, insights, anomalias, conformidade
- API Infrastructure: Saúde do sistema, licenciamento, gerenciamento de usuários
- API OneManage: Inventário de dispositivos, topologia
- API Orchestration: Workflows e automação
Segurança em Primeiro Lugar:
- HTTPS com certificados autoassinados (gerados automaticamente)
- Autenticação multiusuário com controle de acesso baseado em funções (RBAC)
- Modo somente leitura por padrão com ativação explícita do modo de edição
- Armazenamento de credenciais criptografadas com Fernet
- Registro de auditoria completo com rastreamento de IP do cliente
- Lista de permissões granular de operações por função
Interface Web de Gerenciamento:
- Interface de gerenciamento baseada em Next.js com HTTPS
- Gerenciamento de usuários e funções
- Monitoramento de saúde do sistema em tempo real
- Visualizador de logs de auditoria com exportação CSV
- Gerenciamento de clusters com teste de conexão
- Painel de configuração de segurança
- Orientação de API e gerenciamento de workflows
Pronto para Empresas:
- Banco de dados PostgreSQL para persistência
- Implantação baseada em Docker com rede de host
- Trilha de auditoria completa para conformidade
- Suporte à integração LDAP

Início Rápido

Pré-requisitos

Docker 20.10+ e Docker Compose 2.0+
Cisco Nexus Dashboard 4.1+ com NDFC 12.x
Node.js 18+ (para acesso MCP remoto via mcp-remote)

1. Clone e Configure

git clone https://github.com/beye91/nexus-dashboard-mcp.git
cd nexus-dashboard-mcp

# Create environment file with your server's IP address
echo "CERT_SERVER_IP=YOUR_SERVER_IP" > .env

Substitua YOUR_SERVER_IP pelo endereço IP real do seu servidor (por exemplo, 192.168.1.213).

2. Inicie os Serviços

docker compose up -d --build

Isso irá:

Gerar certificados SSL autoassinados automaticamente
Iniciar o banco de dados PostgreSQL (porta 15432)
Iniciar a API Web com HTTPS (porta 8444)
Iniciar a interface Web com HTTPS (porta 7443)
Iniciar o servidor MCP para integração com o Claude

3. Configuração Inicial

Abra seu navegador e acesse:
```
https://YOUR_SERVER_IP:7443
```
Aceite o aviso de certificado autoassinado
Conclua a configuração inicial do administrador:
- Nome de usuário: admin
- E-mail: admin@example.com
- Senha: Admin123! (ou sua senha preferida)
Configure seu primeiro cluster:
- Navegue até a página Clusters
- Clique em "Adicionar Novo Cluster"
- Insira os detalhes do seu Nexus Dashboard
- Clique em "Testar Conexão" para verificar
- Salve a configuração do cluster

4. Configure o Claude Desktop

Adicione à sua configuração do Claude Desktop:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

Implantação Remota (Recomendada)

{
  "mcpServers": {
    "nexus-dashboard": {
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://YOUR_SERVER_IP:8444/mcp/sse",
        "--transport",
        "sse-only"
      ]
    }
  }
}

Substitua YOUR_SERVER_IP pelo endereço IP do seu servidor.

Nota: Como usamos certificados autoassinados, talvez seja necessário definir NODE_TLS_REJECT_UNAUTHORIZED=0 no seu ambiente ou aceitar o certificado no armazenamento de confiança do seu sistema.

Implantação Local (mesma máquina do Docker)

{
  "mcpServers": {
    "nexus-dashboard": {
      "command": "docker",
      "args": [
        "exec",
        "-i",
        "nexus-mcp-server",
        "python",
        "src/main.py"
      ]
    }
  }
}

Reinicie o Claude Desktop e você verá as ferramentas do Nexus Dashboard disponíveis!

Arquitetura

                      External Clients
                  (Browser, Claude Desktop)
                           |
                    [HTTPS/TLS]
                           |
           +---------------+---------------+
           |                               |
      Port 7443                       Port 8444
           |                               |
+----------+----------+    +---------------+--------------+
|       Web UI        |    |           Web API            |
|      (Next.js)      |--->|          (FastAPI)           |
|      HTTPS Proxy    |    |  +----------+  +---------+   |
+---------------------+    |  | REST API |  | MCP SSE |   |
                           |  +----------+  +---------+   |
                           +---------------+--------------+
                                           |
                    +----------------------+----------------------+
                    |                      |                      |
           +--------+--------+    +--------+--------+    +--------+--------+
           |   PostgreSQL    |    |   MCP Server    |    | Nexus Dashboard |
           |   Port 15432    |    |   (stdio)       |    |   Clusters      |
           +-----------------+    +-----------------+    +-----------------+

Certificate Volume: /app/certs/ (auto-generated on first startup)

Resumo de Portas

Serviço	Porta	Protocolo	Descrição
Interface Web	7443	HTTPS	Interface de gerenciamento
API Web	8444	HTTPS	API REST e endpoint MCP SSE
PostgreSQL	15432	TCP	Banco de dados (mapeado de 5432)
HTTP Interno	8001	HTTP	Comunicação interna de proxy

Variáveis de Ambiente

Obrigatórias para Produção

Crie um arquivo .env com:

# Your server's IP address (for SSL certificate SAN)
CERT_SERVER_IP=192.168.1.213

# Security (generate unique keys for production)
ENCRYPTION_KEY=your-unique-fernet-key
SESSION_SECRET_KEY=your-random-secret-key

# Optional: Nexus Dashboard defaults (can be configured via Web UI)
NEXUS_CLUSTER_URL=https://nexus-dashboard.example.com
NEXUS_USERNAME=admin
NEXUS_PASSWORD=YourPassword

Gerar Chave de Criptografia:

python3 -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

Variáveis Opcionais

# SSL Certificate Configuration
CERT_DAYS=365                    # Certificate validity (default: 365)
CERT_CN=nexus-dashboard          # Certificate common name

# Security
EDIT_MODE_ENABLED=false          # Enable write operations
MCP_API_TOKEN=your-token         # Optional: Require token for MCP access

# Logging
LOG_LEVEL=INFO                   # DEBUG, INFO, WARNING, ERROR

Segurança

Configuração HTTPS

Os certificados autoassinados são gerados automaticamente na primeira inicialização:

Armazenados no volume Docker nexus-mcp-certs
Válidos por 365 dias (configurável via CERT_DAYS)
Inclui localhost, 127.0.0.1 e o IP do seu servidor no SAN

Para regenerar certificados:

docker volume rm nexus-mcp-certs
docker compose up -d

RBAC Multiusuário

A plataforma suporta vários usuários com controle de acesso baseado em funções:

Função Admin: Acesso total a todas as operações
Função Operador: Acesso de leitura + operações de escrita específicas
Função Visualizador: Acesso somente leitura

Os usuários podem ser gerenciados pela interface Web em Segurança > Usuários.

Melhores Práticas

Altere a senha padrão do administrador após a configuração inicial
Mantenha EDIT_MODE_ENABLED=false a menos que operações de escrita sejam necessárias
Use chaves de criptografia fortes para produção
Revise os logs de auditoria regularmente para detectar atividades não autorizadas
Limite o acesso de rede ao servidor

Documentação

Guia de Início Rápido - Comece a usar em 5 minutos
Visão Geral da Arquitetura - Design do sistema e componentes
Guia do Usuário - Documentação abrangente de uso
Guia da Interface Web - Gerenciando o sistema pela interface web
Configuração do Claude Desktop - Integração detalhada com o Claude
Guia de Implantação - Recomendações de implantação em produção
RBAC Multiusuário - Controle de acesso baseado em funções
Sistema de Orientação de API - Personalizando o comportamento da API

Solução de Problemas

Verificar Status do Contêiner

docker compose ps
docker compose logs -f

Problemas de Certificado

# View certificate details
docker compose exec web-api openssl x509 -in /app/certs/server.crt -text -noout

# Regenerate certificates
docker volume rm nexus-mcp-certs
docker compose up -d

Problemas de Banco de Dados

# Connect to database
docker compose exec postgres psql -U mcp_user -d nexus_mcp

# Check tables
\dt

# View audit logs
SELECT * FROM audit_log ORDER BY timestamp DESC LIMIT 10;

Conectividade de Rede

# Test API endpoint
curl -k https://localhost:8444/api/health

# Test Web UI
curl -k https://localhost:7443

Desenvolvimento

Configuração de Desenvolvimento Local

# Clone repository
git clone https://github.com/beye91/nexus-dashboard-mcp.git
cd nexus-dashboard-mcp

# Create virtual environment
python -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Start database only
docker compose up postgres -d

# Run API locally
python src/api/web_api.py

# Run Web UI in dev mode
cd web-ui
npm install
npm run dev

Licença

Este projeto está licenciado sob a Apache License 2.0 - consulte o arquivo LICENSE para obter detalhes.

Agradecimentos

Anthropic - Pela plataforma de IA Claude e pelo protocolo MCP
Cisco - Pelas APIs do Nexus Dashboard
FastMCP - Pelo excelente framework MCP

Feito com carinho para automação de rede