Skip to main content
Glama
elvatis

elvatis-mcp

Official
by elvatis

elvatis-mcp

Servidor MCP para OpenClaw -- expón tu hogar inteligente, memoria, automatización cron y orquestación de subagentes de IA a Claude Desktop, Cursor, Windsurf y cualquier cliente de IA compatible con MCP.

npm License Tests AAHP Verify

¿Qué es esto?

elvatis-mcp conecta Claude (o cualquier cliente MCP) a tu infraestructura:

  • Control del hogar inteligente a través de Home Assistant (luces, termostatos, aspiradora, sensores)

  • Sistema de memoria con registros diarios almacenados en tu servidor OpenClaw

  • Gestión y activación de tareas cron

  • Orquestación multi-LLM a través de 5 backends de IA: Claude, OpenClaw, Google Gemini, OpenAI Codex y LLMs locales

  • División inteligente de prompts que analiza solicitudes complejas, enruta subtareas a la IA adecuada y ejecuta el plan con límite de velocidad (rate limiting)

La idea clave: Claude es el orquestador, pero puede delegar trabajo especializado a otros modelos de IA. Las tareas de codificación van a Codex. La investigación va a Gemini. El formateo simple va a tu LLM local (gratuito y privado). El trading y la automatización van a OpenClaw. prompt_split resuelve el enrutamiento automáticamente, y prompt_split_execute ejecuta el plan con límite de velocidad en agentes en la nube.

Related MCP server: hass-mcp-server

¿Qué es MCP?

Model Context Protocol es un estándar abierto de Anthropic que permite a los clientes de IA conectarse a servidores de herramientas externos. Una vez configurado, Claude puede llamar directamente a tus herramientas sin copiar y pegar.


Arquitectura Multi-LLM

                         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

Comparación de Subagentes

Herramienta

Backend

Transporte

Autenticación

Mejor para

Costo

claude_run

Claude (Anthropic)

CLI local

Inicio de sesión de Claude Code

Razonamiento complejo, redacción, revisión de código. Para clientes MCP que no son de Claude.

Uso de API

openclaw_run

OpenClaw (plugins)

SSH

Clave SSH

Trading, automatizaciones, flujos de trabajo de varios pasos

Autohospedado

gemini_run

Google Gemini

CLI local

Inicio de sesión de Google

Contexto largo (1M de tokens), multimodal, investigación

Uso de API

codex_run

OpenAI Codex

CLI local

Inicio de sesión de OpenAI

Codificación, depuración, edición de archivos, scripts de shell

Uso de API

local_llm_run

LM Studio / Ollama / llama.cpp

HTTP

Ninguno

Clasificación, formateo, extracción, reescritura

Gratis

Reanudación de Sesión

claude_run, gemini_run y codex_run utilizan la reanudación de sesión CLI para eliminar la sobrecarga de arranque en frío. En la primera llamada se crea una nueva sesión; las llamadas posteriores la reanudan para que el modelo reciba solo el mensaje nuevo en lugar de volver a procesar todo el historial de la conversación.

Métrica

Sin reanudación de sesión

Con reanudación de sesión

Tamaño del prompt por solicitud

18-25 KB

<1 KB (solo mensaje nuevo)

Tiempo de respuesta de Claude Sonnet

80-120 s (50 % de tasa de bloqueo)

5-10 s

Tasa de bloqueo silencioso

~50 %

Casi 0 %

Las sesiones se guardan en ~/.openclaw/cli-bridge/cli-sessions.json y caducan después de 2 horas de inactividad o 50 solicitudes. El session_id se devuelve en cada respuesta para que puedas inspeccionar qué sesión se utilizó.

División Inteligente de Prompts

La herramienta prompt_split analiza prompts complejos y los divide en subtareas:

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)

Usa prompt_split_execute para ejecutar el plan automáticamente, o deja que Claude lo ejecute paso a paso. Las tareas se ejecutan en orden de dependencia con grupos paralelos ejecutados simultáneamente. Hay tres estrategias de análisis:

Estrategia

Velocidad

Calidad

Usos

heuristic

Instantánea

Buena para prompts claros

Coincidencia de palabras clave, sin llamada LLM

local

5-30 s

Mejor razonamiento

Tu LLM local analiza el prompt

gemini

5-15 s

Mejor calidad

Gemini-flash analiza el prompt

auto (predeterminado)

Varía

La mejor disponible

Omite prompts simples y luego prueba gemini -> local -> heuristic


Herramientas Disponibles (34 en total)

Home Assistant (7 herramientas)

Herramienta

Descripción

home_get_state

Leer el estado de cualquier entidad de Home Assistant

home_light

Controlar luces: encendido/apagado/alternar, brillo, temperatura de color, RGB

home_climate

Controlar termostatos Tado: temperatura, modo HVAC

home_scene

Activar escenas de Hue por habitación

home_vacuum

Controlar la aspiradora Roborock: iniciar, detener, base, estado

home_sensors

Leer todos los sensores de temperatura, humedad y CO2

home_automation

Listar, activar, habilitar o deshabilitar automatizaciones de HA

Memoria (3 herramientas)

Herramienta

Descripción

openclaw_memory_write

Escribir una nota en el registro diario de hoy

openclaw_memory_read_today

Leer el registro de memoria de hoy

openclaw_memory_search

Buscar archivos de memoria en los últimos N días

Automatización Cron (7 herramientas)

Herramienta

Descripción

openclaw_cron_list

Listar todos los trabajos cron programados de OpenClaw

openclaw_cron_run

Activar un trabajo cron inmediatamente por ID

openclaw_cron_status

Obtener el estado del programador y el historial de ejecución reciente

openclaw_cron_create

Crear un nuevo trabajo cron (expresión cron, intervalo o de una sola vez)

openclaw_cron_edit

Editar un trabajo cron existente (nombre, mensaje, programación, modelo)

openclaw_cron_delete

Eliminar un trabajo cron por ID

openclaw_cron_history

Mostrar el historial de ejecución reciente de un trabajo cron

Agente OpenClaw (4 herramientas)

Herramienta

Descripción

openclaw_run

Enviar un prompt al agente de IA de OpenClaw (todos los plugins disponibles)

openclaw_status

Comprobar si el demonio de OpenClaw se está ejecutando

openclaw_plugins

Listar todos los plugins instalados

openclaw_notify

Enviar una notificación a través de WhatsApp, Telegram o el último canal utilizado

Subagentes de IA (5 herramientas)

Herramienta

Descripción

claude_run

Enviar un prompt a Claude a través de la CLI local. Para clientes MCP que no son de Claude (Cursor, Windsurf).

gemini_run

Enviar un prompt a Google Gemini a través de la CLI local. Contexto de 1M de tokens.

codex_run

Enviar una tarea de codificación a OpenAI Codex a través de la CLI local.

local_llm_run

Enviar un prompt a un LLM local (LM Studio, Ollama, llama.cpp). Gratuito y privado. Admite transmisión.

llama_server

Iniciar/detener/configurar un servidor llama.cpp con soporte de caché TurboQuant.

Gestión del Sistema (4 herramientas)

Herramienta

Descripción

system_status

Comprobar el estado de todos los servicios a la vez con latencia (HA, SSH, LLM, CLIs)

local_llm_models

Listar, cargar o descargar modelos en LM Studio / Ollama

openclaw_logs

Ver registros de puerta de enlace, agente o sistema del servidor OpenClaw

file_transfer

Subir, descargar o listar archivos en el servidor OpenClaw a través de SSH

Enrutamiento y Orquestación (3 herramientas)

Herramienta

Descripción

mcp_help

Mostrar la guía de enrutamiento. Pasa una tarea para obtener una recomendación de herramienta específica.

prompt_split

Analizar un prompt complejo y dividirlo en subtareas con asignaciones de agente.

prompt_split_execute

Ejecutar un plan dividido: enviar subtareas a los agentes en orden de dependencia con límite de velocidad.

Panel de control

Punto de conexión

Descripción

http://localhost:3334/status

Panel HTML de actualización automática (estado del servicio, modelos cargados)

http://localhost:3334/api/status

API JSON para comprobaciones de estado programáticas


Resultados de las Pruebas

Todas las pruebas se ejecutan contra servicios en vivo (LM Studio con Deepseek R1 Qwen3 8B, servidor OpenClaw a través de 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
  -----------------------------------------------------------

Ejecuta las pruebas tú mismo:

npx tsx tests/integration.test.ts

Requisitos previos: .env configurado, servidor LLM local en ejecución, servidor OpenClaw accesible por SSH.


Puntos de Referencia

Consulta BENCHMARKS.md para ver el conjunto completo de puntos de referencia, la metodología y la guía de contribución comunitaria.

Hardware de Referencia

Componente

Especificación

CPU

AMD Threadripper 3960X (24 núcleos / 48 subprocesos)

GPU

AMD Radeon RX 9070 XT Elite (16 GB GDDR6)

RAM

128 GB DDR4

SO

Windows 11 Pro

Tiempo de ejecución

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

Inferencia LLM Local (LM Studio, GPU Vulkan, --gpu max)

Mediana de 3 ejecuciones, max_tokens=512. Tareas: clasificar (sentimiento de 1 palabra), extraer (JSON), razonar (aritmética), codificar (función de Python). Vulkan es el tiempo de ejecución recomendado para AMD RX 9070 XT (gana en 4 de 5 modelos sobre ROCm).

Model

Params

classify

extract

reason

code

avg 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

Aceleración de GPU frente a CPU (Deepseek R1 8B, Vulkan): classify 7.2 veces más rápido, extract 3.8 veces más rápido.

Comparación de subagentes (misma tarea, diferentes backends)

Agente

Backend

Latencia media

Coste

Notas

local_llm_run

GPT-OSS 20B (Vulkan GPU)

1.0s

Gratis

4 veces más rápido que Codex, 6 veces más rápido que Claude

codex_run

OpenAI Codex CLI

4.1s

De pago

Ideal para tareas de programación

claude_run

Claude Sonnet 4.6

6.3s (5-10s con reanudación de sesión)

De pago

Ideal para razonamiento complejo

gemini_run

Gemini 2.5 Flash

34.0s

Plan gratuito

Sobrecarga de inicio de CLI, ideal para contexto largo

Latencia del servicio (system_status)

Servicio

Latencia

Notas

Home Assistant (REST API)

48-84 ms

Red local, HTTP directo

OpenClaw SSH

273-299 ms

SSH en LAN + ejecución de comandos

Local LLM (lista de modelos)

19-38 ms

API local de LM Studio

Claude CLI (comprobación de versión)

472-478 ms

Sobrecarga de inicio de CLI

Codex CLI (comprobación de versión)

131-136 ms

Sobrecarga de inicio de CLI

Gemini CLI (comprobación de versión)

4,700-4,900 ms

Inicio de CLI + comprobación de autenticación

Precisión de prompt_split (estrategia heurística)

Métrica

Resultado

Tasa de éxito

10/10 (100 %)

Precisión del recuento de tareas

10/10 (100 %)

Coincidencia media de agente

100 %

Latencia

<1 ms (sin llamada a LLM)

Mejoras en v0.8.0+: coincidencia de expresiones regulares por límites de palabra, división de cláusulas por comas para prompts multiagente, reglas de enrutamiento por herramienta, enrutamiento de openclaw_notify. Consulta BENCHMARKS.md para ver el corpus de pruebas completo.

¿Quieres aportar benchmarks de tu hardware? Consulta BENCHMARKS.md.


Requisitos

  • Node.js 18 o posterior

  • Cliente OpenSSH (integrado en Windows 10+, macOS, Linux)

  • Una instancia de OpenClaw en ejecución accesible por SSH

  • Una instancia de Home Assistant con un token de acceso de larga duración

Opcional (para subagentes):

  • claude_run: npm install -g @anthropic-ai/claude-code y ejecuta claude una vez para autenticarte

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

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

  • local_llm_run: cualquier servidor local compatible con OpenAI:

    • LM Studio (recomendado, con interfaz gráfica, puerto predeterminado 1234)

    • Ollama (ollama serve, puerto 11434)

    • llama.cpp (llama-server, cualquier puerto)


Instalación

Instalación global:

npm install -g @elvatis_com/elvatis-mcp

O úsalo directamente con npx (sin necesidad de instalación):

npx @elvatis_com/elvatis-mcp

Cada versión se compila y publica con GitHub Actions a partir de una etiqueta v* enviada, desde el commit exacto que nombra esa etiqueta. SECURITY.md explica qué garantiza y qué no garantiza ese proceso, y cómo verificar una versión instalada. CHANGELOG.md documenta el contenido de cada versión.


¿Dónde puedo usarlo?

elvatis-mcp funciona en cualquier cliente compatible con MCP. Cada cliente usa su propio archivo de configuración.

Cliente

Transporte

Archivo de configuración

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, todos los proyectos)

stdio

~/.claude.json

Claude Code (solo este proyecto)

stdio

.mcp.json en la raíz del repositorio (ya incluido)

Cursor / Windsurf / otros

stdio o HTTP

Consulta la documentación de la aplicación

Claude Desktop y Cowork comparten el mismo archivo de configuración. Claude Code es un sistema separado.


Configuración

1. Crea tu archivo .env

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. Configura tu cliente MCP

Claude Desktop (macOS)

Edita ~/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)

Abre este archivo (créealo si es necesario):

%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"
      }
    }
  }
}

En Windows, usa siempre rutas absolutas completas. El entorno limitado de MSIX no resuelve ~ ni rutas relativas.

Claude Code (este proyecto)

Copia .mcp.json.example a .mcp.json (ignorado por git, nunca se confirma) y completa tus rutas y datos SSH. Luego copia .env.example a .env para la configuración restante.

Claude Code (global)

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

Transporte HTTP (clientes remotos)

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

Conecta tu cliente a http://your-server:3333/mcp.


Variables de entorno

Obligatorias

Variable

Descripción

HA_URL

URL base de Home Assistant, p. ej. http://192.168.x.x:8123

SSH_HOST

Nombre de host o IP del servidor OpenClaw

Opcionales

Variable

Por defecto

Descripción

HA_TOKEN

--

Token de acceso de larga duración de Home Assistant

SSH_PORT

22

Puerto SSH

SSH_USER

chef-linux

Nombre de usuario SSH

SSH_KEY_PATH

~/.ssh/openclaw_tunnel

Ruta a la clave privada SSH

OPENCLAW_GATEWAY_URL

http://localhost:18789

URL de OpenClaw Gateway

OPENCLAW_GATEWAY_TOKEN

--

Token de API de Gateway opcional

OPENCLAW_DEFAULT_AGENT

--

Agente con nombre para openclaw_run

GEMINI_MODEL

gemini-2.5-flash

Modelo por defecto para gemini_run

CODEX_MODEL

--

Modelo por defecto para codex_run

LOCAL_LLM_ENDPOINT

http://localhost:1234/v1

URL del servidor LLM local (por defecto LM Studio)

LOCAL_LLM_MODEL

--

Modelo local por defecto (omítelo para usar el modelo cargado en el servidor)

MCP_TRANSPORT

stdio

Modo de transporte: stdio o http

MCP_HTTP_PORT

3333

Puerto HTTP

SSH_DEBUG

--

Establécelo en 1 para obtener salida SSH detallada

ELVATIS_DATA_DIR

~/.elvatis-mcp

Directorio para datos de uso persistentes (limitador de tasa)

RATE_LIMITS

--

Cadena JSON con anulaciones de límite de tasa por agente


Configuración de LLM local

elvatis-mcp funciona con cualquier servidor local compatible con OpenAI. Tres opciones populares:

LM Studio (recomendado para escritorio)

  1. Descárgalo de lmstudio.ai

  2. Carga un modelo (p. ej. Deepseek R1 Qwen3 8B, Phi 4 Mini)

  3. Haz clic en "Local Server" en la barra lateral y actívalo

  4. El servidor se ejecuta en http://localhost:1234/v1 (el predeterminado)

Ollama

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

Establece LOCAL_LLM_ENDPOINT=http://localhost:11434/v1 en tu .env.

llama.cpp

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

Establece LOCAL_LLM_ENDPOINT=http://localhost:8080/v1 en tu .env.

Modelos recomendados por tarea

Modelo

Tamaño

Ideal para

Phi 4 Mini

3B

Clasificación, formato y extracción rápidos

Deepseek R1 Qwen3

8B

Razonamiento, análisis y división de prompts

Phi 4 Reasoning Plus

15B

Razonamiento complejo con calidad

GPT-OSS

20B

Propósito general, respuestas más largas

Los modelos de razonamiento (Deepseek R1, Phi 4 Reasoning) envuelven su cadena de pensamiento en etiquetas thinking. elvatis-mcp las elimina automáticamente para darte respuestas limpias.


Configuración de SSH

Las herramientas cron, memory y OpenClaw se comunican con tu servidor a través de SSH.

# 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

En Windows, elvatis-mcp resuelve automáticamente el binario SSH a C:\Windows\System32\OpenSSH\ssh.exe y reintenta en fallos de conexión transitorios. Establece SSH_DEBUG=1 para obtener una salida detallada.


Comando de barra /mcp-help

En Claude Code, el comando de barra /mcp-help muestra la guía completa de enrutamiento de 34 herramientas como salida formateada:

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

Límite de tasa

Los subagentes en la nube (claude_run, codex_run, gemini_run) tienen límite de tasa para evitar costes descontrolados. Límites predeterminados:

Agente

/min

/h

/día

Coste est./llamada

claude_run

5

30

200

$0.03

codex_run

5

30

200

$0.02

gemini_run

10

60

500

$0.01

Los agentes locales (local_llm_run, home_*, openclaw_*) son ilimitados.

Los datos de uso se guardan en ~/.elvatis-mcp/usage.json. Anula los límites mediante la variable de entorno RATE_LIMITS:

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

Desarrollo

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

Compila en modo observador:

npm run dev

Ejecuta las pruebas de integración:

npx tsx tests/integration.test.ts

Estructura del proyecto

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

Licencia

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