de en es ja ko ru zh

DivLens MCP

Name: DivLens MCP
Author: Lohithry

by Lohithry

Overview Schema Source Related Servers Discussions Admin

Rust

Local

¿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.

Related MCP server: GhostInTheShell MCP

✦ 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.

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Living MemoryOAuth
to.viibe
An MCP memory server. One memory your agents share — across models, devices and apps.
Knowledge & Memory Autonomous Agents AI & Machine Learning
22
pronto-stream A
io.github.nmxmxh
Real-time planetary signal engine and Model Context Protocol (MCP) server for autonomous AI agents.
Agent Orchestration Cryptocurrency Finance
151
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
UnifAPIOAuth
com.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Open Data Search AI & Machine Learning
2

Related MCP Servers

open-monitor
Monitoring Observability
hasna
A
license
Not graded
quality
F
maintenance
Multi-machine system monitor with a built-in MCP server that enables AI agents to query health metrics, manage processes, schedule cron jobs, and run diagnostics across local and remote machines.
Updated 2 months ago (2026-08-14 13:02 UTC)
133 npm
Apache 2.0
GhostInTheShell MCP
Monitoring Observability Shell Access
pronzzz
A
license
Not graded
quality
D
maintenance
A sandboxed, read-only MCP server that safely exposes system metrics, container diagnostics, and logs to AI agents with intelligent context compression and strict security measures.
Updated 8 months ago (2026-02-20 20:24 UTC)
MIT
hwprobe-mcp
Monitoring Command Line
notreallycheeks
A
license
A
quality
D
maintenance
Hardware probe MCP server that provides deep hardware inventory and live sensor telemetry for AI agents, including CPU, memory, disk, GPU, and sensor data across platforms.
Updated 3 months ago (2026-07-17 03:20 UTC)
6
MIT
system-monitor
2428424081cn
A
license
A
quality
D
maintenance
A secure, read-only MCP server for AI-powered system monitoring. It provides real-time OS metrics, config discovery, and safe log tailing to enable autonomous infrastructure audits without shell access risks.
Updated 3 months ago (2026-07-18 14:59 UTC)
4
1
ISC