¿Qué es DivLens MCP?

DivLens MCP es un servidor de alto rendimiento del Model Context Protocol (MCP) escrito en Rust.

Cierra la brecha entre los asistentes de IA y tu máquina, brindando a Claude, Cursor, Windsurf y cualquier otro agente compatible con MCP acceso estructurado y en vivo a sensores de hardware, métricas de almacenamiento, diagnósticos de red, árboles de procesos, entornos de ejecución para desarrolladores, registros del sistema y más.

Sin nube. Sin claves API. Sin configuración necesaria. Solo compila y ejecuta.

"Why is my Mac slow?" → Claude calls get_live_metrics() → Instant answer.
"Is my SSD healthy?"  → Claude calls get_hardware_diagnostics() → SMART data returned.
"What's eating disk?"  → Claude calls get_advanced_storage_stats() → Largest files listed.

✦ 17 Herramientas de diagnóstico

Categoría	Herramienta	Lo que devuelve
⚡ Rendimiento	`get_live_metrics`	% de CPU, RAM, swap, procesos bloqueados, tiempo de actividad
⚡ Rendimiento	`get_process_list`	Procesos principales por CPU / RAM con PID
💾 Almacenamiento	`get_storage_health`	Espacio libre/usado/total por punto de montaje
💾 Almacenamiento	`scan_storage_inventory`	Inventario completo de tipos de archivo con tamaños
💾 Almacenamiento	`get_file_type_summary`	Recuento y tamaños de archivos por extensión
💾 Almacenamiento	`get_specific_file_type`	Todos los archivos que coinciden con una extensión específica
💾 Almacenamiento	`get_advanced_storage_stats`	Los 50 archivos más grandes + análisis de datos obsoletos
💾 Almacenamiento	`get_storage_diagnostics`	IOPS, latencia de lectura/escritura, estado SMART
🖥️ Hardware	`get_hardware_diagnostics`	Especificaciones de CPU/GPU, % de batería, temperaturas, SMART
🌐 Red	`get_network_diagnostics`	Rendimiento, conexiones activas, señal
🌐 Red	`get_network_config`	IP, DNS, configuración de interfaz por adaptador
🔬 Identidad	`get_system_dna`	SO, nombre de host, tiempo de actividad, huella digital de la máquina
🛠️ Stack Dev	`get_dev_stack`	Entornos de ejecución de Node, Python, Rust, Go, Java + paquetes
🛠️ Stack Dev	`get_drivers`	Módulos del kernel y controladores de dispositivos
📂 Utilidad	`scan_directory`	Listado recursivo de directorios con tamaños
🧠 Memoria	`recall_memory`	Búsqueda semántica sobre diagnósticos de IA pasados
📋 Registros	`get_system_logs`	Errores recientes del SO/kernel agrupados por patrón

🚀 Instalación: Un comando, cualquier plataforma

No se requiere Rust. Sin compilación. Sin edición manual de configuración. El instalador descarga un binario precompilado y configura automáticamente tus clientes de IA.

macOS y Linux

curl -fsSL https://raw.githubusercontent.com/Lohithry/divlens-mcp/main/install.sh | bash

Windows (PowerShell: no se requieren privilegios de administrador)

irm https://raw.githubusercontent.com/Lohithry/divlens-mcp/main/install.ps1 | iex

El instalador hará lo siguiente:

✅ Detectará tu SO y arquitectura (Apple Silicon / Intel / Linux / Windows)
✅ Descargará el binario precompilado correcto desde GitHub Releases
✅ Verificará la suma de comprobación SHA-256
✅ Instalará en tu PATH sin necesidad de derechos de administrador
✅ Configurará automáticamente Claude Desktop, Cursor, Windsurf y Antigravity
✅ Probará que el servidor funcione antes de finalizar

Luego, simplemente reinicia tu cliente de IA y pregunta: "¿Qué está usando mi CPU en este momento?"

Compilar desde el código fuente (Avanzado)

Requiere Rust 1.82+.

git clone https://github.com/Lohithry/divlens-mcp.git
cd divlens-mcp/apps/core
cargo build --release
./target/release/divlens-core --mcp

Conéctate a tu IA

Claude Desktop

Archivo de configuración: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows)

{
  "mcpServers": {
    "divlens": {
      "command": "/usr/local/bin/divlens-core",
      "args": ["--mcp"]
    }
  }
}

Cierra y reinicia Claude Desktop. Un icono de enchufe 🔌 confirmará la conexión.

Cursor

Archivo de configuración: ~/.cursor/mcp.json

{
  "mcpServers": {
    "divlens": {
      "command": "/usr/local/bin/divlens-core",
      "args": ["--mcp"]
    }
  }
}

Cmd+Shift+P → Reload Window

Windsurf

Archivo de configuración: ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "divlens": {
      "command": "/usr/local/bin/divlens-core",
      "args": ["--mcp"]
    }
  }
}

Para obtener detalles completos de la configuración, consulta DEPLOYMENT.md.

Cómo funciona

  ┌─────────────────────────────────────────┐
  │   AI Client  (Claude / Cursor / etc.)   │
  │         LLM reasoning lives here        │
  └──────────────────┬──────────────────────┘
                     │  JSON-RPC 2.0  (stdio)
                     ▼
  ┌─────────────────────────────────────────┐
  │          divlens-core  (Rust)           │
  │                                         │
  │  ┌───────────────┐  ┌───────────────┐   │
  │  │  MCP Layer    │  │  17 Tools     │   │
  │  │  (JSON-RPC)   │  │  (Rust + OS)  │   │
  │  └───────────────┘  └───────────────┘   │
  │  ┌───────────────┐  ┌───────────────┐   │
  │  │  SQLite Cache │  │  Native APIs  │   │
  │  │  (sysinfo/OS) │  │  (IOKit/WMI)  │   │
  │  └───────────────┘  └───────────────┘   │
  └─────────────────────────────────────────┘

      Zero cloud.  Zero API keys.  100% local.

Transporte: Cada mensaje MCP es un objeto JSON-RPC 2.0 delimitado por nuevas líneas sobre stdio. Lógica de IA: DivLens nunca ejecuta inferencia de LLM; solo recopila y devuelve datos brutos del sistema. Privacidad: Todos los datos permanecen en tu máquina. No se envía nada a ninguna parte.

Estructura del proyecto

divlens-mcp/
└── apps/
    └── core/                      # Rust MCP engine
        ├── src/
        │   ├── tools/             # 17 tool implementations
        │   ├── mcp/               # JSON-RPC 2.0 protocol handler
        │   ├── mcp_server.rs      # stdio transport loop
        │   ├── collectors/        # Native OS data collectors
        │   │   ├── volatile/      # CPU, RAM, network (live)
        │   │   ├── persistent/    # Storage, hardware (cached)
        │   │   └── ondemand/      # Drivers, logs, packages
        │   ├── modules/           # Core business logic
        │   ├── db/                # SQLite caching layer
        │   ├── models/            # Shared data types
        │   └── utils/             # Shell env rehydration
        ├── Cargo.toml
        └── env.example

Opcional: Memoria semántica

Habilita la característica vector-memory para darle a recall_memory una verdadera búsqueda semántica utilizando un modelo de incrustación (embedding) ONNX local (sin nube, sin clave API):

cargo build --release --features vector-memory

Cuando está habilitado, DivLens crea un almacén vectorial local LanceDB y utiliza fastembed para incrustar y recordar diagnósticos pasados de forma semántica.

Cuando está deshabilitado (predeterminado), recall_memory devuelve una lista vacía; no se pierde ninguna funcionalidad.

Verificar el servidor

Prueba el protocolo de comunicación MCP sin un cliente:

# Initialize handshake
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","clientInfo":{"name":"test","version":"0.1"}}}' \
  | divlens-core --mcp

# Call a tool directly
echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_live_metrics","arguments":{}}}' \
  | divlens-core --mcp

Licencia

Licenciado bajo la Apache License, Version 2.0. Consulta LICENSE para ver el texto completo.

DivLens MCP