justinX

Connect live streaming data (MQTT, Kafka, Webhook) to your AI agent via MCP with automated alerts and anomaly detection.

Security Scan

The skill's requirements and runtime instructions are consistent with a third‑party MCP integration for streaming data; it asks only for an API key and provides MCP config steps, with no install or unexplained privileges.

Purpose & Capability

The skill claims to connect MQTT/Kafka/webhooks via an MCP endpoint and only requests a JUSTINX_API_KEY which is exactly what an external API-backed streaming service would need. The listed tools (create_connection, read_stream, watchers, WebSocket URLs) match the stated purpose.

Instruction Scope

The SKILL.md instructs the agent/user to add JustinX to MCP settings (examples reference .claude/settings.json and ~/.openclaw/openclaw.json) and to include an Authorization header with the API key. This is expected for an MCP-backed skill, but it requires storing the API key in agent config files (plaintext in examples). The instructions do not ask the agent to read unrelated system files or other credentials.

Install Mechanism

There is no install spec and no code files — this is instruction-only. That minimizes disk write/execute risk; nothing is downloaded or installed by the skill itself.

Credentials

Only one environment secret (JUSTINX_API_KEY) is required, which is proportional to an external API integration. Caveat: the SKILL.md examples show adding the API key into local MCP config files, which can expose the key if those files are not protected. No other unrelated credentials are requested.

Persistence & Privilege

always is false and the skill is user-invocable / can be called autonomously (platform default). The skill asks the user to add an MCP server entry (normal for MCP integrations) but does not request any elevated or system-wide privileges beyond that.

Assessment

This skill appears coherent for connecting streaming data to your agent, but it connects your agent to an external service (justinx.ai) and requires storing an API key in your MCP config. Before installing: 1) Verify the justinx.ai service and repository (the included metadata points to https://justinx.ai and a GitHub repo) so you trust the vendor. 2) Prefer creating a limited-scope API key and rotate/revoke it if needed. 3) Avoid placing keys in world-readable config files — use your agent's secret storage or OS keyring if available. 4) Be aware that streaming data (and any watcher scripts you run) will flow to a third party; do not send sensitive or regulated data until you confirm compliance and privacy details. 5) Test with the provided demo connection and non-sensitive data first.

Use justinx for real-time streaming data -- MQTT brokers, Kafka topics, webhooks -- piped directly into your AI agent via MCP. Connect a data source, read live messages, set up automated alerts and anomaly detection, and get WebSocket URLs to embed in generated apps.

When to use this skill

• You need to connect to an MQTT broker (IoT sensors, industrial telemetry, smart devices)
• You need to consume from Kafka topics
• You need a webhook endpoint to receive pushed data
• You want to build a live dashboard on streaming data
• You need automated alerting or anomaly detection on a data stream
• You want a WebSocket URL that any frontend can subscribe to for real-time updates

Setup

1. Get an API key

Sign up at https://justinx.ai and copy your API key from Dashboard > Settings.

2. Configure the MCP server

Add JustinX as an MCP server. Choose one of the following methods depending on your environment.

Direct MCP config (Claude Code, Cursor, or any MCP client):

Add to your MCP settings (e.g. .claude/settings.json, ~/.openclaw/openclaw.json, or your tool's MCP config):

{
  "mcpServers": {
    "justinx": {
      "url": "https://api.justinx.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Via mcporter (if you have the mcporter skill installed):

mcporter add justinx --url https://api.justinx.ai/mcp --header "Authorization: Bearer YOUR_API_KEY"

Then call tools with:

mcporter call justinx.list_connections
mcporter call justinx.create_connection type=mqtt broker=broker.emqx.io topics='["sensors/#"]'

Tools reference

Tool	Purpose
create_connection	Connect to MQTT broker, Kafka cluster, or create a webhook endpoint
list_connections	List all active connections with status and WebSocket URLs
get_connection	Get a specific connection's status, message count, and WebSocket URL
destroy_connection	Tear down a connection and clean up its stream
read_stream	Sample live entries from a connection (backfill + live window)
create_watcher	Create a managed automation on a connection (alerting, aggregation)
list_watchers	List watchers with status, PID, and restart count
get_watcher	Get watcher details and configuration
get_watcher_logs	Read stdout/stderr from a running or crashed watcher
update_watcher_config	Update a watcher's JSON config (restarts automatically)
restart_watcher	Restart a stopped or crashed watcher
delete_watcher	Stop and remove a watcher

Common workflows

Connect to an MQTT broker and read data

# Connect to a public IoT demo broker
create_connection type=mqtt broker=broker.emqx.io port=8883 tls=true topics=["justinx/demo/#"]

# Read the last 5 minutes of data + 3 seconds of live entries
read_stream connectionId=<id> backfillSeconds=300 liveSeconds=3 maxEntries=50

For a private broker with credentials:

create_connection type=mqtt broker=my-broker.example.com port=8883 tls=true username=myuser password=mypass topics=["sensors/#","alerts/#"]

Create a webhook endpoint

# Creates an HTTP ingest URL -- POST JSON to it and messages appear in the stream
create_connection type=webhook

# The response includes an ingestUrl. Send data to it:
# POST https://api.justinx.ai/connections/<id>/ingest

Connect to Kafka

create_connection type=kafka brokers=["kafka1.example.com:9092"] kafkaTopics=["events","logs"]

# With SASL auth:
create_connection type=kafka brokers=["kafka.example.com:9092"] kafkaTopics=["events"] saslUsername=user saslPassword=pass ssl=true

Create a watcher for alerts

Watchers are managed automations that continuously monitor a connection for conditions you define — threshold alerts, metric aggregation, or notifications. Each watcher is scoped to a single connection.

# Create a watcher that alerts when temperature exceeds a threshold
create_watcher connectionId=<id> config='{"threshold": 45}'

# The platform provides a script template. See https://justinx.ai/docs for
# watcher script examples and the full scripting reference.

Manage watchers

# List all watchers on a connection
list_watchers connectionId=<id>

# Check logs for debugging
get_watcher_logs connectionId=<id> watcherId=<wid>

# Update threshold without redeploying
update_watcher_config connectionId=<id> watcherId=<wid> config='{"threshold": 50}'

# Restart a crashed watcher
restart_watcher connectionId=<id> watcherId=<wid>

# Remove a watcher
delete_watcher connectionId=<id> watcherId=<wid>

Build a live dashboard

After creating a connection, use the WebSocket URL from the response to build a frontend:

1. Call create_connection or list_connections to get the WebSocket URL
2. The WebSocket sends a backfill message on connect (recent history), then individual entry messages in real time
3. Each entry has { id, fields: { topic, payload }, ts } format
4. Pass the WebSocket URL to any generated React/Next.js/HTML app

WebSocket message format:

// Backfill (sent once on connect)
{ "type": "backfill", "entries": [{ "id": "...", "fields": { "topic": "...", "payload": "..." }, "ts": 1234567890 }] }

// Live entry (streamed continuously)
{ "type": "entry", "id": "...", "fields": { "topic": "...", "payload": "..." }, "ts": 1234567890 }

Topic filtering: append ?topics=sensor/temp,sensor/humidity to the WebSocket URL.

Tips

• Every new account gets a demo connection to broker.emqx.io with live IoT data -- call list_connections to find it
• Use read_stream with backfillSeconds=0 liveSeconds=5 to see only fresh data
• Watcher config is passed as a JSON string and can be updated without redeploying
• Watcher alerts appear on the connection's WebSocket stream automatically
• The WebSocket URL works from any client (browser, Node.js, Python, mobile) -- no SDK needed
• Full tool reference and parameter schemas: https://justinx.ai/llms-full.txt