Skip to main content
Glama
elvatis

elvatis-mcp

Official
by elvatis

elvatis-mcp

MCP-Server für OpenClaw – macht dein Smart Home, Speichersystem, Cron-Automatisierung und die Orchestrierung von KI-Sub-Agenten für Claude Desktop, Cursor, Windsurf und jeden MCP-kompatiblen KI-Client verfügbar.

npm License Tests AAHP Verify

Was ist das?

elvatis-mcp verbindet Claude (oder jeden MCP-Client) mit deiner Infrastruktur:

  • Smart-Home-Steuerung über Home Assistant (Lichter, Thermostate, Staubsauger, Sensoren)

  • Speichersystem mit täglichen Protokollen, die auf deinem OpenClaw-Server gespeichert werden

  • Cron-Verwaltung und Auslösung von Cron-Jobs

  • Multi-LLM-Orchestrierung über 5 KI-Backends: Claude, OpenClaw, Google Gemini, OpenAI Codex und lokale LLMs

  • Intelligente Prompt-Aufteilung, die komplexe Anfragen analysiert, Teilaufgaben an die richtige KI weiterleitet und den Plan mit Rate-Limiting ausführt

Die Grundidee: Claude ist der Orchestrierer, kann aber spezialisierte Arbeit an andere KI-Modelle delegieren. Programmieraufgaben gehen an Codex. Recherchen gehen an Gemini. Einfache Formatierung geht an dein lokales LLM (kostenlos, privat). Trading und Automatisierung gehen an OpenClaw. prompt_split ermittelt das Routing automatisch, und prompt_split_execute führt den Plan mit Rate-Limiting für Cloud-Agenten aus.

Related MCP server: hass-mcp-server

Was ist MCP?

Das Model Context Protocol ist ein offener Standard von Anthropic, der es KI-Clients ermöglicht, sich mit externen Tool-Servern zu verbinden. Nach Konfiguration kann Claude deine Tools direkt aufrufen – ganz ohne Kopieren und Einfügen.


Multi-LLM-Architektur

                         You (Claude Desktop / Code / Cursor)
                                      |
                              MCP Protocol (stdio/HTTP)
                                      |
                              elvatis-mcp server
                                      |
              +--------+--------+--------+--------+--------+--------+
              |        |        |        |        |        |        |
          Claude  OpenClaw  Gemini   Codex   Local   llama   Home
          (CLI)   (SSH)     (CLI)    (CLI)   LLM    .cpp    Asst.
              |        |        |        |    (HTTP)  (proc)  (REST)
          Reason  Plugins  1M ctx  Coding    |        |        |
          Write   Trading  Multi-  Files   LM Stu  Turbo-  Lights
          Review  Auto.    modal   Debug   Ollama  Quant   Climate
                  Notify   Rsch    Shell   (free!) cache   Vacuum

Sub-Agenten-Vergleich

Tool

Backend

Transport

Authentifizierung

Am besten geeignet für

Kosten

claude_run

Claude (Anthropic)

Lokale CLI

Claude-Code-Login

Komplexes Denken, Schreiben, Code-Review. Für Nicht-Claude-MCP-Clients.

API-Nutzung

openclaw_run

OpenClaw (Plugins)

SSH

SSH-Key

Trading, Automatisierung, mehrstufige Workflows

Selbstgehostet

gemini_run

Google Gemini

Lokale CLI

Google-Login

Langer Kontext (1 Mio. Tokens), multimodal, Recherche

API-Nutzung

codex_run

OpenAI Codex

Lokale CLI

OpenAI-Login

Programmierung, Debugging, Dateibearbeitung, Shell-Skripte

API-Nutzung

local_llm_run

LM Studio / Ollama / llama.cpp

HTTP

Keine

Klassifizierung, Formatierung, Extraktion, umschreiben

Kostenlos

Sitzungswiederaufnahme bei Sessions

claude_run, gemini_run und codex_run nutzen die CLI-Sitzungswiederaufnahme, um den Cold-Start-Overhead zu eliminieren. Beim ersten Aufruf wird eine neue Sitzung erstellt; nachfolgende Aufrufe führen sie fort, sodass das Modell nur die neue Nachricht erhält, statt den gesamten Gesprächsverlauf erneut zu verarbeiten.

Metrik

Ohne Sitzungswiederaufnahme

Mit Sitzungswiederaufnahme

Größe des Prompts pro Anfrage

18–25 KB

<1 KB (nur die neue Nachricht)

Antwortzeit von Claude Sonnet

80–120 s (50 % Hänger-Rate)

5–10 s

Stille Hänger-Rate

~50 %

Nahe bei 0 %

Sitzungen werden in ~/.openclaw/cli-bridge/cli-sessions.json gespeichert und nach 2 Stunden Inaktivität oder 50 Anfragen ungültig. In jeder Antwort wird die session_id zurückgegeben, damit du prüfen kannst, welche Sitzung verwendet wurde.

Intelligente Prompt-Aufteilung

Das Tool prompt_split analysiert komplexe Prompts und zerlegt sie in Teilaufgaben:

User: "Search my memory for TurboQuant notes, summarize with Gemini,
       reformat as JSON locally, then save a summary to memory"

prompt_split returns:
  t1: openclaw_memory_search  -- "Search memory for TurboQuant"        (parallel)
  t3: local_llm_run           -- "Reformat raw notes as clean JSON"    (parallel)
  t2: gemini_run              -- "Summarize the key findings"          (after t1)
  t4: openclaw_memory_write   -- "Save summary to today's log"        (after t2, t3)

Verwende prompt_split_execute, um den Plan automatisch auszuführen, oder lass Claude ihn Schritt für Schritt ausführen. Aufgaben werden in Abhängigkeitsreihenfolge verarbeitet, wobei parallele Gruppen gleichzeitig ausgeführt werden. Es gibt drei Analyse-Strategien:

Strategie

Geschwindigkeit

Qualität

Verwendungszweck

heuristic

Sofort

Gut für eindeutige Prompts

Schlüsselwort-Matching, kein LLM-Aufruf

local

5–30 s

Bestes Reasoning

Dein lokales LLM analysiert den Prompt

gemini

5–15 s

Beste Qualität

Gemini-Flach analysiert den Prompt

auto (Standard)

Variabel

Bestmögliche

Kurzschließt einfache Prompts, versucht dann gemini → local → heuristic


Verfügbare Tools (insgesamt 34)

Home Assistant (7 Tools)

Tool

Beschreibung

home_get_state

Liest den Zustand eines beliebigen Home-Assistant-Knotens

home_light

Steuert die Beleuchtung: an/aus/umschalten, Helligkeit, Farbtemperatur, RGB

home_climate

Steuert Tado-Thermostate: Temperatur, HVAC-Modus

home_scene

Aktiviert Hue-Szenen pro Raum

home_vacuum

Steuert den Roborock-Saugroboter: starten, stoppen, zur Ladestation, Status

home_sensors

Liest alle Temperatur-, Feuchtigkeits- und CO2-Sensoren

home_automation

Listet HA-Automatisierungen auf, löst sie aus, aktiviert oder deaktiviert sie

Speicher (3 Tools)

Tool

Beschreibung

openclaw_memory_write

Schreibt eine Notiz in das heutige Tagesloggment

openclaw_memory_read_today

Listet das heutige Speicherprotokoll

openclaw_memory_search

Durchsucht Speicherdateien der letzten N Tage über N Tage

Cron-Automatisierung (7 Tools)

Tool

Beschreibung

openclaw_cron_list

Listet alle geplanten OpenClaw-Cron-Jobs auf

openclaw_cron_run

Löst einen Cron-Job sofort per ID aus

openclaw_cron_status

Ruft den Scheduler-Status und den Verlauf der letzten Ausführungen ab

openclaw_cron_create

Erstellt einen neuen Cron-Job (Cron-Ausdruck, Intervall oder einmalig)

openclaw_cron_edit

Bearbeitet einen Cron-Job (Name, Nachricht, Zeitplan, Modell)

openclaw_cron_delete

Löscht einen Cron-Job per ID

openclaw_cron_history

Zeigt den Verlauf der letzten Ausführungen eines Cron-Jobs

OpenClaw-Agent (4 Tools)

Tool

Beschreibung

openclaw_run

Sendet einen Prompt an den OpenClaw-KI-Agenten (alle Plugins aktiviert)

openclaw_status

Prüft, ob der OpenClaw-Daemon läuft

openclaw_plugins

Listet alle installierten Plugins auf

openclaw_notrash

Sendet eine Benachrichtigung über WhatsApp, Telegram oder den zuletzt genutzten Kanal

KI-Sub-Agenten (5 Tools)

Tool

Beschreibung

claude_run

Sendet einen Prompt an Claude über die lokale CLI. Für Nicht-Claude-MCP-Clients (Cursor, Windsurf).

gemini_run

Sendet einen Prompt an Google Gemini über die lokale CLI. 1-Mio.-Token-Kontext.

codex_run

Sendet eine Programmieraufgabe an OpenAI Codex über die lokale CLI.

local_llm_run

Sendet einen Prompt an ein lokales LLM (LM Studio, Ollama, llama.cpp). Kostenlos, privat. Unterstützt Streaming.

llama_server

Startet/stoppt/konfiguriert einen llama.cpp-Server mit TurboQuant-Cache-Unterstützung.

Systemverwaltung (4 Tools)

Tool

Beschreibung

system_status

Health-Check für alle Dienste gleichzeitig mit Latenz (HA, SSH, LLM, CLIs)

local_llm_models

Mom- und Entladen von Modellen auf LM Studio / Ollama

openclaw_logs

Anzeigen von Gateway-, Agent- oder Systemprotokollen des OpenClaw-Servers

file_transfer

Hoch-, runter- und Auflisten von Dateien auf dem OpenClaw-Server über SSH

Routing und Orchestrierung (3 Tools)

Tool

Beschreibung

mcp_help

Zeigt einen Routingleitfaden um. Übergib eine Aufgabe, um eine konkrete Hammer-Empfehlung für das Objekt zu erhalten.

prompt_split

Analysiert einen komplexen Prompt und zerlegt ihn in Teilaufgaben mit Agenten-Zuordnung.

prompt_split_execute

Führt einen Split-Plan aus: Teilaufgaben werdenn den AgentL in Anzahl einer Reihenfolge mit Rate-Limiting zugewiesen.

Dashboard

Endpunkt

Beschreibung

http://localhost:3334/status

Automatisch aktualisierendes HTML-Dashboard (Service-Zustand, geladende Modelle)

http://localhost:3334/api/status

JSON-API für programmatische Zustandsabfragen


Testergebnisse

Allenvorab: Alle Tests laufen gegen Live-Dienste (LM Studio mit Deepseek R1 Qwen3 8B, OpenClaw-Server via SSH).

  elvatis-mcp integration tests

  Local LLM (local_llm_run)

        Model: deepseek/deepseek-r1-0528-qwen3-8b
        Response: "negative"
        Tokens: 401 (prompt: 39, completion: 362)
  PASS  local_llm_run: simple classification (21000ms)
        Extracted: {"name":"John Smith","age":34}
  PASS  local_llm_run: JSON extraction (24879ms)
        Error: Could not connect to local LLM at http://localhost:19999/v1/chat/completions
  PASS  local_llm_run: connection error handling (4ms)

  Prompt Splitter (prompt_split)

        Strategy: heuristic
        Agent: codex_run
        Summary: Fix the authentication bug in the login handler
  PASS  prompt_split: single-domain coding prompt routes to codex (1ms)
        Strategy: heuristic
        Subtasks: 3
          t1: codex_run -- "Refactor the auth module"
          t2: openclaw_run -- "check my portfolio performance and"
          t3: home_light -- "turn on the living room lights"
        Parallel groups: [["t1","t3"],["t2"]]
        Estimated time: 90s
  PASS  prompt_split: heuristic multi-agent splitting (0ms)
        Subtasks: 4, Agents: openclaw_memory_write, gemini_run, local_llm_run
        Parallel groups: [["t1","t3","t4"],["t2"]]
  PASS  prompt_split: cross-domain with dependencies (1ms)
        Strategy: local->heuristic (fallback)
        Subtasks: 1
  PASS  prompt_split: local LLM strategy (with fallback) (60007ms)

  Routing Guide (mcp_help)

        Guide length: 2418 chars
  PASS  mcp_help: returns guide without task (0ms)
        Recommendation: local_llm_run (formatting task)
  PASS  mcp_help: routes formatting task to local_llm_run (0ms)
        Recommendation: codex_run (coding task)
  PASS  mcp_help: routes coding task to codex_run (0ms)

  Memory Search via SSH (openclaw_memory_search)

        Query: "trading", Results: 5
  PASS  openclaw_memory_search: finds existing notes (208ms)

  -----------------------------------------------------------
  11 passed, 0 failed, 0 skipped
  -----------------------------------------------------------

Führe die Tests selbst aus:

npx tsx tests/integration.test.ts

Voraussetzungen: .env konfiguriert, lokaler LLM-Server läuft, über SSH erreichbarer OpenClaw-Server.


Benchmarks

Vollständige Benchmark-Suite, Methodik und Anleitung für Community-Beiträge findest du in BENCHMARKS.md.

Referenz-Hardware

Komponente

Spezifikation

CPU

AMD Threadripper 3960X (24 Kerne / 48 Threads)

GPU

AMD Radeon RX 9070 XT Elite (16 GBGDDR6)

RAM

128 GB DDR4ER

OS

Windows 11 Pro

Laufzeit

LM Studio + Vulkan (llama.cpp-win-x86_64-vulkan-avx2@2.8.0

Lokale LLM-Inferenz (LM Studio, Vulkan-GPU, --gpu max)

Median aus 3 Läufen, max_tokens=512. Aufgaben: Klassifizierung (1-Wort-Sentiment), Extraktion (JSON), Schlussfolgerung (Arithmetik), Codegenerierung (Python-Funktion). Vulkan ist die empfohlene Laufzeit für die AMD RX 9070 XT (4 von 5 Modellen gegenüber ROCm gewonnen).

Modell

Parameter

classify

extract

reason

code

Ø tok/s

Phi 4 Mini Reasoning

3B

2.6s

1.9s

4.7s

4.8s

106

Deepseek R1 0528 Qwen3

8B

3.0s

6.5s

7.2s

7.4s

70

Qwen 3.5 9B

9B

6.2s

4.0s

8.4s

7.2s

48

Phi 4 Reasoning Plus

15B

0.4s

9.7s

3.5s

9.9s

40

GPT-OSS 20B

20B

0.6s

0.6s

0.6s

1.9s

63

GPU-Beschleunigung vs. CPU (Deepseek R1 8B, Vulkan): classify 7.2x schneller, extract 3.8x schneller.

Sub-Agent-Vergleich (gleiche Aufgabe, verschiedene Backends)

Agent

Backend

Ø Latenz

Kosten

Hinweise

local_llm_run

GPT-OSS 20B (Vulkan GPU)

1.0s

Kostenlos

4x schneller als Codex, 6x schneller als Claude

codex_run

OpenAI Codex CLI

4.1s

Pay-per-use

Am besten für Programmieraufgaben

claude_run

Claude Sonnet 4.6

6.3s (5-10s bei Sitzungsfortsetzung)

Pay-per-use

Am besten für komplexe Reasoning-Aufgaben

gemini_run

Gemini 2.5 Flash

34.0s

Kostenlose Stufe

CLI-Startup-Overhead, am besten für lange Kontexte

Service-Latenz (system_status)

Service

Latenz

Hinweise

Home Assistant (REST API)

48-84 ms

Lokales Netzwerk, direktes HTTP

OpenClaw SSH

273-299 ms

LAN-SSH + Befehlsausführung

Local-LLM (Modellliste)

19-38 ms

LM Studio localhost-API

Claude CLI (Versionscheck)

472-478 ms

CLI-Startup-Overhead

Codex CLI (Versionscheck)

131-136 ms

CLI-Startup-Overhead

Gemini CLI (Versionscheck)

4.700-4.900 ms

CLI-Startup + Auth-Prüfung

prompt_split-Genauigkeit (heuristische Strategie)

Metrik

Ergebnis

Erfolgsquote

10/10 (100%)

Genauigkeit der Aufgabenanzahl

10/10 (100%)

Ø-Agenten-Übereinstimmung

100%

Latenz

<1ms (kein LLM-Aufruf)

Verbesserungen in v0.8.0+: Regex-Abgleich mit Wortgrenzen, Komma-Splitting bei Klauseln für Multi-Agent-Prompts, Routing-Regeln pro Tool, openclaw_notify-Routing. Den vollständigen Testkorpus findest du in BENCHMARKS.md.

Möchtest du Benchmarks deiner Hardware beitragen? Siehe BENCHMARKS.md.


Anforderungen

  • Node.js 18 oder höher

  • OpenSSH-Client (vorinstalliert auf Windows 10+, macOS, Linux)

  • Eine laufende OpenClaw-Instanz, die per SSH erreichbar ist

  • Eine Home-Assistant-Instanz mit einem langlebigen Zugriffstoken

Optional (für Sub-Agents):

  • claude_run: npm install -g @anthropic-ai/claude-code und einmal claude ausführen, um dich zu authentifizieren

  • gemini_run: npm install -g @google/gemini-cli und gemini auth login

  • codex_run: npm install -g @openai/codex und codex login

  • local_llm_run: ein OpenAI-kompatibler lokaler Server:

    • LM Studio (empfohlen, GUI, Standard-Port 1234)

    • Ollama (ollama serve, Port 11434)

    • llama.cpp (llama-server, beliebiger Port)


Installation

Global installieren:

npm install -g @elvatis_com/elvatis-mcp

Oder direkt über npx verwenden (keine Installation erforderlich):

npx @elvatis_com/elvatis-mcp

Jede Version wird von GitHub Actions aus einem gepushten v*-Tag erstellt und veröffentlicht – aus genau dem Commit, den der Tag benannt. SECURITY.md beschreibt, was dieser Ablauf garantiert und was nicht, und wie du eine installierte Version verifizierst. Im CHANGELOG.md ist festgehalten, was jede Version enthält.


Wo kann ich es verwenden?

elvatis-mcp funktioniert in jedem MCP-kompatiblen Client. Jeder Client verwendet seine eigene Konfigurationsdatei.

Client

Transport

Konfigurationsdatei

Claude Desktop / Cowork (Windows MSIX)

stdio

%LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json

Claude Desktop / Cowork (macOS)

stdio

~/Library/Application Support/Claude/claude_desktop_config.json

Claude Code (global, alle Projekte)

stdio

~/.claude.json

Claude Code (nur dieses Projekt)

stdio

.mcp.json im Repository-Root (bereits enthalten)

Cursor / Windsurf / andere

stdio oder HTTP

Siehe App-Dokumentation

Claude Desktop und Cowork nutzen dieselbe Konfigurationsdatei. Claude Code ist ein separates System.


Konfiguration

1. Erstelle deine .env-Datei

cp .env.example .env
# Required
HA_URL=http://your-home-assistant:8123
HA_TOKEN=your_long_lived_ha_token
SSH_HOST=your-openclaw-server-ip
SSH_USER=your-ssh-username
SSH_KEY_PATH=~/.ssh/your_key

# Optional: Local LLM
LOCAL_LLM_ENDPOINT=http://localhost:1234/v1    # LM Studio default
LOCAL_LLM_MODEL=deepseek-r1-0528-qwen3-8b     # or omit to use loaded model

# Optional: Sub-agent models
GEMINI_MODEL=gemini-2.5-flash
CODEX_MODEL=o3

2. Konfiguriere deinen MCP-Client

Claude Desktop (macOS)

Bearbeite ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "elvatis-mcp": {
      "command": "npx",
      "args": ["-y", "@elvatis_com/elvatis-mcp"],
      "env": {
        "HA_URL": "http://your-home-assistant:8123",
        "HA_TOKEN": "your_token",
        "SSH_HOST": "your-openclaw-server-ip",
        "SSH_USER": "your-username",
        "SSH_KEY_PATH": "/Users/your-username/.ssh/your_key"
      }
    }
  }
}

Claude Desktop (Windows MSIX)

Öffne diese Datei (erstelle sie bei Bedarf):

%LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "elvatis-mcp": {
      "command": "C:\\Program Files\\nodejs\\node.exe",
      "args": ["C:\\path\\to\\elvatis-mcp\\dist\\index.js"],
      "env": {
        "HA_URL": "http://your-home-assistant:8123",
        "HA_TOKEN": "your_token",
        "SSH_HOST": "your-openclaw-server-ip",
        "SSH_USER": "your-username",
        "SSH_KEY_PATH": "C:\\Users\\your-username\\.ssh\\your_key"
      }
    }
  }
}

Unter Windows immer vollständige absolute Pfade angeben. Die MSIX-Sandbox erkennt ~ oder relative Pfade nicht auf.

Claude Code (dieses Projekt)

Kopiere .mcp.json.example nach .mcp.json (gitignored, wird nie committet) und trage deine Pfade und SSH-Daten ein. Kopiere danach .env.example nach .env für die restliche Konfiguration.

Claude Code (global)

claude mcp add --scope user elvatis-mcp -- node /path/to/elvatis-mcp/dist/index.js

HTTP-Transport (Remote-Clients)

MCP_TRANSPORT=http MCP_HTTP_PORT=3333 npx @elvatis_com/elvatis-mcp

Verbinde deinen Client mit http://dein-server:3333/mcp.


Umgebungsvariablen

Steuerung Hauptbeschreibung:

Erforderlich

Variable

Beschreibung

HA_URL

Home-Assistant-Basis-URL, z.B. http://192.168.x.x:8123

SSH_HOST

Hostname oder IP des OpenClaw-Servers

Optional

Variable

Standard

Beschreibung

HA_TOKEN

Langlebiges Home-Assistant-Zugriffstoken

SSH_PORT

22

SSH-Port

SSH_USER

chef-linux

SSH-Benutzername

SSH_KEY_PATH

~/.ssh/openclaw_tunnel

Pfad zum SSH-

OPENCLAW_GATEWAY_URL

http://localhost:18789

URL des OpenClaw-Gateways

OPENCLAW_GATEWAY_TOKEN

Optionales API-Token für das Gateway

OPENCLAW_DEFAULT_AGENT

Benannter Agent für openclaw_run

GEMINI_MODEL

gemini-2.5-flash

Standardmodell für gemini_run

CODEX_MODEL

Standardmodell für codex_run

`graphql_LLM_ENDPOINT

`

http://localhost:1234/v1

URL des lokalen LLM-Servers (LM-Studio-Standard)

LOCAL_LLM_MODEL

Standardmodellfür das lokale LLM (leer lassen, um das geladene Modell des Servers zu verwenden)

MCP_TRANSPORT

stdio

Transportmodus: stdio oder http

MCP_HTTP_PORT

3333

HTTP-Port

SSH_DEBUG

Auf 1 setzen für ausführliche SSH-Ausgabe

ELVATIS_DATA_DIR

~/.elvatis-mcp

Verzeichnis für dauerhafte Nutzungsdaten (Ratenbegrenzung)

RATE_LIMITS

JSON-String mit Überschreibungen der Ratenbegrenzungen pro Agent


Lokales LLM-Setup

elvatis-mcp funktioniert mit jedem OpenAI-kompatiblen lokalen Server. Drei verkzeugte Optionen:

LM Studio (empfohlen für Desktop)

  1. Lade es herunter von lmstudio.ai

  2. Lade ein Modell (z.B. Deepseek R1 Qwen3 8B, Phi 4 Mini)

  3. Klicke in der Seitenleiste auf „Local Server“ und aktiviere es

  4. Der Server läuft unter http://localhost:1234/v1 (Standard)

Ollama

ollama serve                    # starts server on port 11434
ollama run llama3.2             # downloads and loads model

Setze LOCAL_LLM_ENDPOINT=http://localhost:11434/v1 in deiner .env.

llama.cpp

llama-server -m model.gguf --port 8080

setze LOCAL_LLM_ENDPOINT=http://localhost:8080/v1 in deiner .env.

Empfohlene Modelle nach Aufgabe

Modell

Größe

Beste Wahl für

Phi 4 Mini

3B

Schnelle Klassifizierung, Formatierung, Extraktion

Deepseek R1 Qwen3

8B

Reasoning, Analyse, Prompt-Splitting

Phi 4 Reasoning Plus

15B

Komplexes Reasoning mit hoher Qualität

GPT-OSS

20B

Allgemeine Zwecke, längere Antworten

Reasoning-Modelle (Deepseek R1, Phi 4 Reasoning) umgeben ihre Gedankengänge mit ``-tags. elvatis-mcp entfernt diese automatisch, um dir saubere Antworten zu liefern.


SSH-Einrichtung

Die cron-, Memory- und OpenClaw-Tools kommunizieren per SSH mit deinem Server.

Auf Windows löst elvatis-mcp den SSH-Binary automatisch über ssh.exe unter C:\Windows\System32\OpenSSH\ssh.exe auf und wiederholt bei temporären Verbindungsfehlern. Setze SSH_DEBUG=1 für ausführliche Ausgabe.

# Verify connectivity
ssh -i ~/.ssh/your_key your-username@your-server "openclaw --version"

# Optional: SSH tunnel for OpenClaw WebSocket gateway
ssh -i ~/.ssh/your_key -L 18789:127.0.0.1:18789 -N your-username@your-server

Slash-Befehl /mcp-help

In Claude Code zeigt der Slash-Befehl /mcp-help den kompletten Routing-Guide für alle 34 Tools als formatierte Ausgabe an:

/mcp-help                           # full guide
/mcp-help openclaw_status           # help for a specific tool
/mcp-help analyze this trading strategy for risk  # routing recommendation

Ratenbegrenzung

Cloud- Sub-Agents (claude_run, codex_run, gemini_run) sind ratenbegrenzt, um unkontrollierbare Kosten zu verhindern. Standardeinstellungen:

Agent

/min

/Std

/Tag

Geschätzte Kosten

claude_run

5

30

200

$0.03

codex_run

5

30

200

$0.02

gemini_run

10

60

500

$0.01

Lokale Agents (local_llm_run, home_*, openclaw_*) sind unbegrenzt.

Nutzungsdaten werden persistent in ~/.elvatis-mcp/usage.json gespeichert. Überschreibe Raten mit der Umgebungsvariable RATE_LIMITS:

RATE_LIMITS='{"claude_run":{"perMinute":3,"perDay":100}}'

Entwicklung

Entwicklungsmodus:

git clone https://github.com/elvatis/elvatis-mcp
cd elvatis-mcp
npm install          # builds automatically via prepare script
cp .env.example .env # fill in your values
node dist/index.js   # starts in stdio mode, waits for MCP client

Watch-Modus für den Live-Build:

npm run dev

Integrationstests ausführen:

npx tsx tests/integration.test.ts

Projektstruktur

src/
  index.ts              MCP server entry, tool registration, transport, dashboard
  config.ts             Environment variable configuration
  dashboard.ts          Status dashboard HTML renderer
  ssh.ts                SSH exec helper (Windows/macOS/Linux)
  spawn.ts              Local process spawner for CLI sub-agents (supports stdin piping)
  session-registry.ts   CLI session registry: persist/resume Claude, Gemini, Codex sessions
  tools/
    home.ts             Home Assistant: light, climate, scene, vacuum, sensors
    home-automation.ts  HA automations: list, trigger, enable, disable
    memory.ts           Daily memory log: write, read, search (SSH)
    cron.ts             OpenClaw cron: list, run, status (SSH)
    cron-manage.ts      OpenClaw cron: create, edit, delete, history (SSH)
    openclaw.ts         OpenClaw agent orchestration (SSH)
    openclaw-logs.ts    OpenClaw server log viewer (SSH)
    notify.ts           WhatsApp/Telegram notifications via OpenClaw
    claude.ts           Claude sub-agent (local CLI, for non-Claude clients)
    gemini.ts           Google Gemini sub-agent (local CLI)
    codex.ts            OpenAI Codex sub-agent (local CLI)
    local-llm.ts        Local LLM sub-agent (OpenAI-compatible HTTP)
    local-llm-models.ts LM Studio model management (list/load/unload)
    llama-server.ts     llama.cpp server manager (start/stop/configure)
    file-transfer.ts    File upload/download via SSH
    system-status.ts    Unified health check across all services
    splitter.ts         Smart prompt splitter (multi-strategy)
    split-execute.ts    Plan executor with agent dispatch and rate limiting
    help.ts             Routing guide and task recommender
    routing-rules.ts    Shared routing rules and keyword matching
  rate-limiter.ts       Rate limiting + cost tracking for cloud sub-agents
tests/
  unit.test.ts          42 unit tests (no external services needed)
  integration.test.ts   Live integration tests

Lizenz

Apache-2.0 – Copyright 2026 Elvatis

A
license - permissive license
A
quality
A
maintenance

Maintenance

Maintainers
14hResponse time
4wRelease cycle
6Releases (12mo)
Commit activity
Issues opened vs closed

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

View all related MCP servers

Related MCP Connectors

  • MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.

  • An MCP memory server. One memory your agents share — across models, devices and apps.

  • Cloud-hosted MCP server for durable AI memory

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/elvatis/elvatis-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server