Nexus Dashboard

Un servidor completo del Protocolo de Contexto de Modelo (MCP) para Cisco Nexus Dashboard, que permite a agentes de IA como Claude interactuar con las API de Nexus Dashboard para la automatización y gestión inteligente de redes.

GitHub

Prueba este MCPPatrocinado

Documentación

Servidor MCP de Nexus Dashboard

Un servidor completo del Protocolo de Contexto de Modelo (MCP) para Cisco Nexus Dashboard, que permite a agentes de IA como Claude interactuar con las APIs de Nexus Dashboard para la automatización y gestión inteligente de redes.

Características

Capacidades principales

Cobertura completa de API: Acceso a más de 638 operaciones en 5 APIs de Nexus Dashboard
- Manage API (146 endpoints): Fabrics, switches, VLANs, VRFs, redes, interfaces
- Analyze API: Telemetría, información, anomalías, cumplimiento
- Infrastructure API: Salud del sistema, licencias, gestión de usuarios
- OneManage API: Inventario de dispositivos, topología
- Orchestration API: Flujos de trabajo y automatización
Seguridad ante todo:
- HTTPS con certificados autofirmados (generados automáticamente)
- Autenticación multiusuario con control de acceso basado en roles (RBAC)
- Modo de solo lectura por defecto con habilitación explícita del modo de edición
- Almacenamiento de credenciales cifrado con Fernet
- Registro de auditoría completo con seguimiento de IP del cliente
- Lista blanca granular de operaciones por rol
Interfaz de gestión web:
- Interfaz de gestión basada en Next.js con HTTPS
- Gestión de usuarios y roles
- Monitoreo de salud del sistema en tiempo real
- Visor de registros de auditoría con exportación CSV
- Gestión de clústeres con prueba de conexión
- Panel de configuración de seguridad
- Guía de API y gestión de flujos de trabajo
Listo para empresas:
- Base de datos PostgreSQL para persistencia
- Implementación basada en Docker con red de host
- Rastro de auditoría completo para cumplimiento
- Soporte de integración LDAP

Inicio rápido

Requisitos previos

Docker 20.10+ y Docker Compose 2.0+
Cisco Nexus Dashboard 4.1+ con NDFC 12.x
Node.js 18+ (para acceso MCP remoto mediante mcp-remote)

1. Clonar y configurar

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

Reemplace YOUR_SERVER_IP con la dirección IP real de su servidor (por ejemplo, 192.168.1.213).

2. Iniciar servicios

docker compose up -d --build

Esto:

Generará certificados SSL autofirmados automáticamente
Iniciará la base de datos PostgreSQL (puerto 15432)
Iniciará la Web API con HTTPS (puerto 8444)
Iniciará la interfaz web con HTTPS (puerto 7443)
Iniciará el servidor MCP para la integración con Claude

3. Configuración inicial

Abra su navegador y vaya a:
```
https://YOUR_SERVER_IP:7443
```
Acepte la advertencia del certificado autofirmado
Complete la configuración inicial de administrador:
- Nombre de usuario: admin
- Correo electrónico: admin@example.com
- Contraseña: Admin123! (o su contraseña preferida)
Configure su primer clúster:
- Navegue a la página Clusters
- Haga clic en "Add New Cluster"
- Ingrese los detalles de su Nexus Dashboard
- Haga clic en "Test Connection" para verificar
- Guarde la configuración del clúster

4. Configurar Claude Desktop

Agregue a su configuración de 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

Implementación remota (recomendada)

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

Reemplace YOUR_SERVER_IP con la dirección IP de su servidor.

Nota: Dado que usamos certificados autofirmados, es posible que deba configurar NODE_TLS_REJECT_UNAUTHORIZED=0 en su entorno o aceptar el certificado en el almacén de confianza de su sistema.

Implementación local (misma máquina que Docker)

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

Reinicie Claude Desktop y verá las herramientas de Nexus Dashboard disponibles.

Arquitectura

                      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)

Resumen de puertos

Servicio	Puerto	Protocolo	Descripción
Interfaz web	7443	HTTPS	Interfaz de gestión
Web API	8444	HTTPS	API REST y endpoint MCP SSE
PostgreSQL	15432	TCP	Base de datos (mapeado desde 5432)
HTTP interno	8001	HTTP	Comunicación interna de proxy

Variables de entorno

Requeridas para producción

Cree un archivo .env con:

# 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

Generar clave de cifrado:

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

Variables opcionales

# 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

Seguridad

Configuración HTTPS

Los certificados autofirmados se generan automáticamente en el primer inicio:

Almacenados en el volumen de Docker nexus-mcp-certs
Válidos por 365 días (configurable mediante CERT_DAYS)
Incluye localhost, 127.0.0.1 y la IP de su servidor en SAN

Para regenerar los certificados:

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

RBAC multiusuario

La plataforma admite múltiples usuarios con control de acceso basado en roles:

Rol de administrador: Acceso completo a todas las operaciones
Rol de operador: Acceso de lectura + operaciones de escritura específicas
Rol de visor: Acceso de solo lectura

Los usuarios se pueden gestionar a través de la interfaz web en Security > Users.

Mejores prácticas

Cambie la contraseña de administrador predeterminada después de la configuración inicial
Mantenga EDIT_MODE_ENABLED=false a menos que se necesiten operaciones de escritura
Use claves de cifrado seguras para producción
Revise los registros de auditoría regularmente para detectar actividad no autorizada
Limite el acceso de red al servidor

Documentación

Guía de inicio rápido - Póngase en marcha en 5 minutos
Descripción general de la arquitectura - Diseño del sistema y componentes
Guía del usuario - Documentación completa de uso
Guía de la interfaz web - Gestión del sistema mediante la interfaz web
Configuración de Claude Desktop - Integración detallada de Claude
Guía de implementación - Recomendaciones de implementación en producción
RBAC multiusuario - Control de acceso basado en roles
Sistema de guía de API - Personalización del comportamiento de la API

Solución de problemas

Verificar el estado de los contenedores

docker compose ps
docker compose logs -f

Problemas de certificados

# 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 base de datos

# 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;

Conectividad de red

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

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

Desarrollo

Configuración de desarrollo 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

Licencia

Este proyecto está licenciado bajo la Apache License 2.0; consulte el archivo LICENSE para más detalles.

Agradecimientos

Anthropic - Por la plataforma de IA Claude y el protocolo MCP
Cisco - Por las APIs de Nexus Dashboard
FastMCP - Por el excelente marco de trabajo MCP

Hecho con dedicación para la automatización de redes