Litmus MCP Server

What is Litmus MCP Server about?

Litmus MCP Server provides a Model Context Protocol (MCP) interface that lets large language models and intelligent systems interact with Litmus Edge devices. It exposes a set of API functions for environment configuration, device discovery, tag access, Docker container management, and cloud‑activation status, all streamed via Server‑Sent Events (SSE).

How to use Litmus MCP Server?

Docker Quick Launch

docker run -d --name litmus-mcp-server -p 8000:8000 ghcr.io/litmusautomation/litmus-mcp-server:main

SSE Endpoint
- Client connects to http://<server-ip>:8000/sse for real‑time streaming.
- Requests are sent via regular HTTP POST.
Integration Configuration (example for Cursor, Claude Desktop, VS Code, Windsurf)
```
{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<IP Address>:8000/sse"
    }
  }
}
```
Place the JSON in the appropriate location for the IDE or tool (e.g., ~/.cursor/mcp.json, claude_desktop_config.json, .vscode/mcp.json, ~/.codeium/windsurf/mcp_config.json).

Key Features

Edge System Config – retrieve and update Litmus Edge connection settings.
DeviceHub Management – list drivers, devices, tags, and fetch current tag values.
Device Identity – get/set a friendly name for the Edge instance.
LEM Integration – check cloud activation and Litmus Edge Manager status.
Docker Management – list containers on Litmus Edge and launch new containers from the Marketplace.
Topic Subscription – subscribe to live values on Litmus Edge topics, with optional batch retrieval for plotting.
Server‑Sent Events transport – low‑latency, bi‑directional communication suitable for LLM‑driven workflows.

Use Cases

LLM‑driven device configuration – an AI assistant can call update_environment_config or update_config to re‑configure a Litmus Edge gateway on the fly.
Real‑time monitoring dashboards – SSE stream feeds live tag values to visualisation tools or chat interfaces.
Automated container deployment – orchestrate edge workloads using run_docker_container_on_litmusedge from within an AI workflow.
IDE integration – developers can invoke MCP functions directly from Cursor, VS Code Copilot, Claude Desktop, or Windsurf to prototype edge‑automation scripts.
Cloud‑edge status checks – get_cloud_activation_status helps maintain compliance and connectivity awareness.

FAQ

How do I start the server? Use the Docker command shown above; the server listens on 0.0.0.0:8000/sse by default.
What client libraries are needed? Any MCP‑compatible client can connect via the SSE endpoint; no additional libraries are required for basic HTTP POST requests.
Can I run the server locally without Docker? The repository contains the source code; building it follows the language‑specific instructions in the repo (e.g., Go or Python build steps).
How do I secure the endpoint? Deploy behind a reverse proxy with TLS termination and enforce authentication at the proxy layer.
Which IDEs support this server out of the box? Cursor, Claude Desktop, VS Code (Copilot), and Windsurf all support MCP configuration via a simple JSON file as illustrated.

The official Litmus Automation Model Context Protocol (MCP) Server enables LLMs and intelligent systems to interact with Litmus Edge for device configuration, monitoring, and management. It is built on top of the MCP SDK and adheres to the Model Context Protocol spec.

Getting Started
- Quick Launch (Docker)
- Cursor IDE Setup
Tools
Usage
- Server-Sent Events (SSE)
Litmus Central
Integrations

Getting Started

Quick Launch (Docker)

Run the server in Docker:

docker run -d --name litmus-mcp-server -p 8000:8000 ghcr.io/litmusautomation/litmus-mcp-server:latest

Cursor IDE Setup

Example mcp.json configuration:

{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<MCP_SERVER_IP>:8000/sse",
      "headers": {
        "EDGE_URL": "https://<LITMUSEDGE_IP>",
        "EDGE_API_CLIENT_ID": "<oauth2_client_id>",
        "EDGE_API_CLIENT_SECRET": "<oauth2_client_secret>",

        "NATS_SOURCE": "<LITMUSEDGE_IP>",
        "NATS_PORT": "4222",
        "NATS_USER": "<access_token_username>",
        "NATS_PASSWORD": "<access_token_from_litmusedge>",

        "INFLUX_HOST": "<LITMUSEDGE_IP>",
        "INFLUX_PORT": "8086",
        "INFLUX_DB_NAME": "tsdata",
        "INFLUX_USERNAME": "<datahub_username>",
        "INFLUX_PASSWORD": "<datahub_password>"
      }
    }
  }
}

Header Configuration Guide:

EDGE_URL: Litmus Edge base URL (include https://)
EDGE_API_CLIENT_ID / EDGE_API_CLIENT_SECRET: OAuth2 credentials from Litmus Edge
NATS_SOURCE: Litmus Edge IP (no http/https)
NATS_USER / NATS_PASSWORD: Access token credentials from System → Access Control → Tokens
INFLUX_HOST: Litmus Edge IP (no http/https)
INFLUX_USERNAME / INFLUX_PASSWORD: DataHub user credentials

See the Cursor docs for more info.

Available Tools

Category	Function Name	Description
DeviceHub	`get_litmusedge_driver_list`	List supported Litmus Edge drivers (e.g., ModbusTCP, OPCUA, BACnet).
	`get_devicehub_devices`	List all configured DeviceHub devices with connection settings and status.
	`create_devicehub_device`	Create a new device with specified driver and default configuration.
	`get_devicehub_device_tags`	Retrieve all tags (data points/registers) for a specific device.
	`get_current_value_of_devicehub_tag`	Read the current real-time value of a specific device tag.
Device Identity	`get_litmusedge_friendly_name`	Get the human-readable name assigned to the Litmus Edge device.
	`set_litmusedge_friendly_name`	Update the friendly name of the Litmus Edge device.
LEM Integration	`get_cloud_activation_status`	Check cloud registration and Litmus Edge Manager (LEM) connection status.
Docker Management	`get_all_containers_on_litmusedge`	List all Docker containers running on Litmus Edge Marketplace.
	`run_docker_container_on_litmusedge`	Deploy and run a new Docker container on Litmus Edge Marketplace.
NATS Topics *	`get_current_value_from_topic`	Subscribe to a NATS topic and return the next published message.
	`get_multiple_values_from_topic`	Collect multiple sequential values from a NATS topic for trend analysis.
InfluxDB **	`get_historical_data_from_influxdb`	Query historical time-series data from InfluxDB by measurement and time range.
Digital Twins	`list_digital_twin_models`	List all Digital Twin models with ID, name, description, and version.
	`list_digital_twin_instances`	List all Digital Twin instances or filter by model ID.
	`create_digital_twin_instance`	Create a new Digital Twin instance from an existing model.
	`list_static_attributes`	List static attributes (fixed key-value pairs) for a model or instance.
	`list_dynamic_attributes`	List dynamic attributes (real-time data points) for a model or instance.
	`list_transformations`	List data transformation rules configured for a Digital Twin model.
	`get_digital_twin_hierarchy`	Get the hierarchy configuration for a Digital Twin model.
	`save_digital_twin_hierarchy`	Save a new hierarchy configuration to a Digital Twin model.

Configuration Notes

* NATS Topic Tools Requirements: To use get_current_value_from_topic and get_multiple_values_from_topic, you must configure access control on Litmus Edge:

Navigate to: Litmus Edge → System → Access Control → Tokens
Create or configure an access token with appropriate permissions
Provide the token in your MCP client configuration headers

** InfluxDB Tools Requirements: To use get_historical_data_from_influxdb, you must allow InfluxDB port access:

Navigate to: Litmus Edge → System → Network → Firewall
Add a firewall rule to allow port 8086 on TCP
Ensure InfluxDB is accessible from the MCP server host

Usage

Server-Sent Events (SSE)

This server supports the MCP SSE transport for real-time communication.

Client endpoint: http://<server-ip>:8000/sse
Default binding: 0.0.0.0:8000/sse
Communication:
- Server → Client: Streamed via SSE
- Client → Server: HTTP POST

Litmus Central

Download or try Litmus Edge via Litmus Central.

Integrations

Cursor IDE

Add to ~/.cursor/mcp.json or .cursor/mcp.json:

{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<MCP_SERVER_IP>:8000/sse",
      "headers": {
        "EDGE_URL": "https://<LITMUSEDGE_IP>",
        "EDGE_API_CLIENT_ID": "<oauth2_client_id>",
        "EDGE_API_CLIENT_SECRET": "<oauth2_client_secret>",
        "NATS_SOURCE": "<LITMUSEDGE_IP>",
        "NATS_PORT": "4222",
        "NATS_USER": "<access_token_username>",
        "NATS_PASSWORD": "<access_token_from_litmusedge>",
        "INFLUX_HOST": "<LITMUSEDGE_IP>",
        "INFLUX_PORT": "8086",
        "INFLUX_DB_NAME": "tsdata",
        "INFLUX_USERNAME": "<datahub_username>",
        "INFLUX_PASSWORD": "<datahub_password>"
      }
    }
  }
}

Cursor docs

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<MCP_SERVER_IP>:8000/sse",
      "headers": {
        "EDGE_URL": "https://<LITMUSEDGE_IP>",
        "EDGE_API_CLIENT_ID": "<oauth2_client_id>",
        "EDGE_API_CLIENT_SECRET": "<oauth2_client_secret>",
        "NATS_SOURCE": "<LITMUSEDGE_IP>",
        "NATS_PORT": "4222",
        "NATS_USER": "<access_token_username>",
        "NATS_PASSWORD": "<access_token_from_litmusedge>",
        "INFLUX_HOST": "<LITMUSEDGE_IP>",
        "INFLUX_PORT": "8086",
        "INFLUX_DB_NAME": "tsdata",
        "INFLUX_USERNAME": "<datahub_username>",
        "INFLUX_PASSWORD": "<datahub_password>"
      }
    }
  }
}

Anthropic Docs

VS Code / GitHub Copilot

Manual Configuration

In VS Code: Open User Settings (JSON) → Add:

{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<MCP_SERVER_IP>:8000/sse",
      "headers": {
        "EDGE_URL": "https://<LITMUSEDGE_IP>",
        "EDGE_API_CLIENT_ID": "<oauth2_client_id>",
        "EDGE_API_CLIENT_SECRET": "<oauth2_client_secret>",
        "NATS_SOURCE": "<LITMUSEDGE_IP>",
        "NATS_PORT": "4222",
        "NATS_USER": "<access_token_username>",
        "NATS_PASSWORD": "<access_token_from_litmusedge>",
        "INFLUX_HOST": "<LITMUSEDGE_IP>",
        "INFLUX_PORT": "8086",
        "INFLUX_DB_NAME": "tsdata",
        "INFLUX_USERNAME": "<datahub_username>",
        "INFLUX_PASSWORD": "<datahub_password>"
      }
    }
  }
}

Or use .vscode/mcp.json in your project.

VS Code MCP Docs

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "litmus-mcp-server": {
      "url": "http://<MCP_SERVER_IP>:8000/sse",
      "headers": {
        "EDGE_URL": "https://<LITMUSEDGE_IP>",
        "EDGE_API_CLIENT_ID": "<oauth2_client_id>",
        "EDGE_API_CLIENT_SECRET": "<oauth2_client_secret>",
        "NATS_SOURCE": "<LITMUSEDGE_IP>",
        "NATS_PORT": "4222",
        "NATS_USER": "<access_token_username>",
        "NATS_PASSWORD": "<access_token_from_litmusedge>",
        "INFLUX_HOST": "<LITMUSEDGE_IP>",
        "INFLUX_PORT": "8086",
        "INFLUX_DB_NAME": "tsdata",
        "INFLUX_USERNAME": "<datahub_username>",
        "INFLUX_PASSWORD": "<datahub_password>"
      }
    }
  }
}

Windsurf MCP Docs

MCP server registries

Glama

MCP.so

Litmus MCP Server