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.

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

DivLens MCP