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

Was ist DivLens MCP?

DivLens MCP ist ein hochperformanter Model Context Protocol (MCP)-Server, der in Rust geschrieben wurde.

Er schließt die Lücke zwischen KI-Assistenten und Ihrem Rechner – und bietet Claude, Cursor, Windsurf und jedem anderen MCP-kompatiblen Agenten live, strukturierten Zugriff auf Hardwaresensoren, Speichermetriken, Netzwerkdiagnosen, Prozessbäume, Entwickler-Runtimes, Systemprotokolle und mehr.

Keine Cloud. Keine API-Schlüssel. Keine Konfiguration erforderlich. Einfach erstellen und ausführen.

"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 Diagnose-Tools

Kategorie	Tool	Rückgabewert
⚡ Leistung	`get_live_metrics`	CPU-%, RAM, Swap, blockierte Prozesse, Betriebszeit
⚡ Leistung	`get_process_list`	Top-Prozesse nach CPU / RAM mit PID
💾 Speicher	`get_storage_health`	Frei/belegt/gesamt pro Mount-Punkt
💾 Speicher	`scan_storage_inventory`	Vollständiges Inventar der Dateitypen mit Größen
💾 Speicher	`get_file_type_summary`	Dateianzahl und -größen nach Endung
💾 Speicher	`get_specific_file_type`	Alle Dateien, die einer bestimmten Endung entsprechen
💾 Speicher	`get_advanced_storage_stats`	Top 50 der größten Dateien + Analyse veralteter Daten
💾 Speicher	`get_storage_diagnostics`	IOPS, Lese-/Schreiblatenz, SMART-Status
🖥️ Hardware	`get_hardware_diagnostics`	CPU/GPU-Spezifikationen, Akku-%, Temperaturen, SMART
🌐 Netzwerk	`get_network_diagnostics`	Durchsatz, aktive Verbindungen, Signal
🌐 Netzwerk	`get_network_config`	IP, DNS, Schnittstellenkonfiguration pro Adapter
🔬 Identität	`get_system_dna`	OS, Hostname, Betriebszeit, Maschinen-Fingerabdruck
🛠️ Dev Stack	`get_dev_stack`	Node, Python, Rust, Go, Java Runtimes + Pakete
🛠️ Dev Stack	`get_drivers`	Kernel-Module und Gerätetreiber
📂 Dienstprogramm	`scan_directory`	Rekursive Verzeichnisauflistung mit Größen
🧠 Speicher	`recall_memory`	Semantische Suche über vergangene KI-Diagnosen
📋 Protokolle	`get_system_logs`	Aktuelle OS/Kernel-Fehler, gruppiert nach Muster

🚀 Installation — Ein Befehl, jede Plattform

Kein Rust erforderlich. Keine Kompilierung. Keine manuelle Konfigurationsbearbeitung. Das Installationsprogramm lädt ein vorkompiliertes Binärprogramm herunter und konfiguriert Ihre KI-Clients automatisch.

macOS & Linux

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

Windows (PowerShell — keine Administratorrechte erforderlich)

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

Das Installationsprogramm wird:

✅ Ihr Betriebssystem und Ihren Chip erkennen (Apple Silicon / Intel / Linux / Windows)
✅ Das korrekte vorkompilierte Binärprogramm von GitHub Releases herunterladen
✅ Die SHA-256-Prüfsumme verifizieren
✅ In Ihren PATH installieren, ohne dass Administratorrechte erforderlich sind
✅ Claude Desktop, Cursor, Windsurf und Antigravity automatisch konfigurieren
✅ Den Server vor Abschluss auf Funktionalität testen

Starten Sie danach einfach Ihren KI-Client neu und fragen Sie: "Was beansprucht gerade meine CPU?"

Aus Quellcode erstellen (Fortgeschritten)

Erfordert 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

Verbindung zu Ihrer KI

Claude Desktop

Konfigurationsdatei: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows)

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

Beenden Sie Claude Desktop und starten Sie es neu. Ein 🔌 Stecker-Symbol bestätigt die Verbindung.

Cursor

Konfigurationsdatei: ~/.cursor/mcp.json

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

Cmd+Shift+P → Reload Window

Windsurf

Konfigurationsdatei: ~/.codeium/windsurf/mcp_config.json

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

Für vollständige Einrichtungsdetails siehe DEPLOYMENT.md.

Funktionsweise

  ┌─────────────────────────────────────────┐
  │   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.

Transport: Jede MCP-Nachricht ist ein zeilenumbruchbegrenztes JSON-RPC 2.0-Objekt über stdio. KI-Logik: DivLens führt niemals LLM-Inferenz aus – es sammelt und liefert lediglich rohe Systemdaten. Datenschutz: Alle Daten verbleiben auf Ihrem Rechner. Nichts wird irgendwohin gesendet.

Projektstruktur

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

Optional: Semantisches Gedächtnis

Aktivieren Sie das vector-memory-Feature, um recall_memory eine echte semantische Suche mittels eines lokalen ONNX-Embedding-Modells zu ermöglichen (keine Cloud, kein API-Schlüssel):

cargo build --release --features vector-memory

Wenn aktiviert, erstellt DivLens einen lokalen LanceDB-Vektorspeicher und verwendet fastembed, um vergangene Diagnosen semantisch einzubetten und abzurufen.

Wenn deaktiviert (Standard), gibt recall_memory eine leere Liste zurück – es gehen keine Funktionen verloren.

Server verifizieren

Testen Sie das MCP-Wire-Protokoll ohne Client:

# 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

Lizenz

Lizenziert unter der Apache License, Version 2.0. Siehe LICENSE für den vollständigen Text.

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

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
https://lme.viibe.to/mcp
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
https://pronto.stream/mcp
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
https://api.anotherai.dev/mcp
Server4Agent A
com.server4agent
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
App Automation Cloud Platforms Developer Tools
383
https://mcp.server4agent.com

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 3 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 10 days ago (2026-10-20 20:39 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