ThingsBoard MCP for AI. Control your entire IoT stack from conversation.

Q: How do I find specific devices using the findentities tool?

You use findentities by providing complex filtering criteria, not just a name. You can search based on multiple parameters like 'status=active' AND 'location=warehouse'. This lets you narrow down your target group precisely.

Q: Can I save sensor data with savetelemetry?

Yes, savetelemetry logs new time-series readings. You must provide the specific entity ID, the metric name (e.g., 'temperature'), and the value you want to record.

Q: What's the difference between sendonewayrpc and sendtwowayrpc?

The key difference is confirmation. sendonewayrpc sends a command and forgets about it (fire-and-forget). sendtwowayrpc, however, requires the device to respond with structured data confirming if the action succeeded or failed.

Q: Does findalarms only show active alerts?

No. You can filter alarms by status and severity using findalarms. This means you can specifically query for 'RESOLVED' alarms to audit past incidents, or 'ACTIVE' alarms with a CRITICAL severity.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

ThingsBoard MCP Server lets your AI agent talk directly to your entire IoT ecosystem. You monitor device telemetry, check alarms by severity, and run commands (RPC) on hardware without opening the dashboard.

It handles reading sensor data, saving attributes, and discovering assets across multiple scopes—all through simple natural language queries.

What your AI can do

Find alarms

Searches for specific alarms by applying filters for severity and status (e.g., active, critical).

Find entities

Uses complex query filters to locate assets, devices, or other entities across the platform.

Get telemetry

Reads and returns the most recent sensor readings (telemetry values) for a specified entity.

+ 4 more capabilities included

Check device sensor data

The agent reads the latest telemetry values for any connected entity.

Update device settings or metadata

You save attributes and time-series data directly to specific entities across defined scopes.

Run commands on hardware

The agent sends both one-way (fire-and-forget) and two-way RPC calls to control physical devices.

Find specific equipment

You search the entire system using complex filters across all available entities, assets, or devices.

Review active alerts

The agent queries and filters alarms based on defined severity levels (e.g., CRITICAL) and status.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

ThingsBoard: 7 Tools for Industrial IoT Management

Use these seven tools to read sensor data, save attributes, manage alerts, and send remote control signals across your entire ThingsBoard-connected ecosystem.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using ThingsBoard on Vinkius

Find Alarms

Searches for specific alarms by applying filters for severity and status (e.g., active, critical).

Find Entities

Uses complex query filters to locate assets, devices, or other entities across the...

Get Telemetry

Reads and returns the most recent sensor readings (telemetry values) for a specified...

Save Attributes

Saves non-time-series data points or metadata (like location/model) to an entity's...

Save Telemetry

Logs a new time-series sensor reading, recording the specific value and timestamp...

Send Oneway Rpc

Sends a command to a device that doesn't require a response or confirmation back to the server.

Send Twoway Rpc

Sends a control command and waits for the physical device to send a structured response confirming the action.

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The ThingsBoard integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "thingsboard": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the ThingsBoard tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"thingsboard": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with ThingsBoard, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by ThingsBoard. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 7 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Debugging device failures shouldn't require jumping through five different vendor dashboards.

Right now, checking a sensor reading means navigating to the central dashboard, finding the asset ID, selecting the correct telemetry type from a dropdown, and finally clicking 'View'. If you have fifty sensors, that’s fifty clicks just to compile a status report.

With this MCP server, you just ask your agent: 'What's the current temperature for Sensor-A?' The process is instant. Your agent runs `get_telemetry`, retrieves the value, and gives it back in natural language. No clicking, no context switching.

ThingsBoard MCP Server: Run full lifecycle IoT control from your chat.

Manual processes involve checking alarms on Dashboard A, then using a separate tool to find the asset ID, and finally submitting a command via an entirely different interface. The workflow is fragmented and slow.

Now? You tell your agent: 'Find all CRITICAL alarms in Zone 3, and if they are associated with a valve, send_oneway_rpc to close it.' It handles discovery (`find_alarms`), filtering, and action (`send_oneway_rpc`)—all in one prompt. That's how it should work.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Yo, listen up. This ThingsBoard MCP Server lets your AI client talk straight to your whole IoT setup. You don't gotta open that dashboard just to check something or flip a switch; you just ask your agent.

If you need to find gear, start with finding it. Use the find_entities tool when you gotta locate specific assets, devices, or any entity across the entire platform using complex query filters. If you're keeping tabs on system alerts, use find_alarms. That lets you search for alarms by filtering on severity—like critical—or status, such as active.

To check what your sensors are doing right now, use get_telemetry. It pulls the absolute latest sensor readings for any entity. If you're updating metadata—the non-time-series stuff like a device’s location or model number—you'll call save_attributes.

Need to log data? Use save_telemetry to record a new time-series sensor reading, specifying the exact value and timestamp for an entity. If you wanna run commands on physical hardware, there are two tools. For commands that don't need confirmation—a straight fire-and-forget action—use send_oneway_rpc. But if the device needs to confirm the action was successful, use send_twoway_rpc.

That sends the control command and waits for the physical hardware to send back a structured response.

Built · Hosted · Managed by Vinkius ThingsBoard MCP Server - IoT Device Control

Server ID 019ea60b-2a89-710a-90ff-7488d40d1f61

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

What Changes When You Connect

Checks telemetry values without leaving chat. Instead of diving into the ThingsBoard dashboard to see if a sensor is working, you just ask for get_telemetry. The agent gives you the latest readings instantly.

Automates remote control logic using RPC calls. Need to cycle power or toggle a valve? You use send_oneway_rpc or send_twoway_rpc, and your agent handles the command execution and status check.

Pinpoints assets with precision. Instead of guessing which sensor is bad, you run find_entities with complex filters to locate every device in a specific zone or model type.

Streamlines incident response. You use find_alarms to pull up all CRITICAL alerts system-wide. This cuts down the time spent manually reviewing alarm logs by hours.

Maintains accurate records easily. Use save_attributes when a device gets updated (e.g., new firmware version) or save_telemetry to log a manual test reading, keeping your data clean.

See it in action

01 01

Investigating an unexpected temperature spike

A facility manager notices a sensor reading is erratic. Instead of manually cross-referencing the device ID in the dashboard, they ask their agent: 'What was the telemetry for Thermostat-42 over the last hour?' The agent runs get_telemetry, retrieving the precise time-series data needed to pinpoint when and why the spike occurred.

02 02

Performing a routine system diagnostic

The DevOps team needs to confirm that all safety relays are operational. They tell their agent: 'Send a two-way RPC command to every relay in Sector B and ask for status.' The agent executes send_twoway_rpc across the group, gathering confirmation responses ('success: true') immediately.

03 03

Auditing critical operational failures

After a power outage, an SRE needs to know the full scope of damage. They ask: 'Show me all active alarms with CRITICAL severity.' The agent runs find_alarms, providing a filtered list that immediately guides repair crews to the worst-hit assets.

04 04

Updating asset metadata after maintenance

A field technician replaces a pump motor and updates its serial number. Instead of logging into the web portal, they tell their agent: 'Update the attributes for Pump 123 with the new SN: XYZ90.' The agent executes save_attributes, updating the asset record instantly.

The honest tradeoffs

Manually checking device status

Anti-pattern

A user needs to check 15 different devices. They open 15 browser tabs, navigate to each one's dashboard, and manually scroll through the telemetry section.

The Fix

Instead, ask your agent: 'Get the latest telemetry for all assets tagged 'Pump' in Zone C.' The agent runs find_entities first, then calls get_telemetry for every relevant device ID. It compiles the full list into one response.

Guessing which asset is affected

Anti-pattern

An alarm triggers, but the user doesn't know if it applies to a device or an entire shared asset. They spend minutes clicking through the hierarchy trying to find the right scope.

The Fix

Use find_entities with complex filters. Specify exactly what you are looking for: 'Find all assets that report high humidity and are located in Building A.' This narrows the search immediately.

Forgetting to confirm a command

Anti-pattern

The user sends an RPC command, but doesn't wait for confirmation. They assume the device worked because they pressed 'send'.

The Fix

Always use send_twoway_rpc. This requires the agent to wait for and interpret the structured response from the physical device. You know for sure if it succeeded or failed.

When It Fits, When It Doesn't

Use this server if your primary workflow involves querying live operational data (telemetry, alarms) or issuing remote control commands across a complex IoT environment. The strength here is the ability to treat these diverse operations—reading data (get_telemetry), writing data (save_attributes/save_telemetry), and commanding hardware (send_twoway_rpc)—as conversational tools.

Don't use this if you only need to view static, archived reports or run simple SQL queries on a dedicated database. For those needs, look for specialized analytics connectors. If your goal is simply basic messaging between two people, an internal chat API would work better than the full IoT stack access provided here.

Questions you might have

How do I find specific devices using the find_entities tool? +

You use find_entities by providing complex filtering criteria, not just a name. You can search based on multiple parameters like 'status=active' AND 'location=warehouse'. This lets you narrow down your target group precisely.

Can I save sensor data with save_telemetry? +

Yes, save_telemetry logs new time-series readings. You must provide the specific entity ID, the metric name (e.g., 'temperature'), and the value you want to record.

What's the difference between send_oneway_rpc and send_twoway_rpc? +

The key difference is confirmation. send_oneway_rpc sends a command and forgets about it (fire-and-forget). send_twoway_rpc, however, requires the device to respond with structured data confirming if the action succeeded or failed.

Does find_alarms only show active alerts? +

No. You can filter alarms by status and severity using find_alarms. This means you can specifically query for 'RESOLVED' alarms to audit past incidents, or 'ACTIVE' alarms with a CRITICAL severity.

How do I use get_telemetry to read the current state of a device? +

It reads the absolute latest sensor values recorded for any given entity. You simply provide the entity ID, and the tool returns the most recent timestamped data points available. This is faster than querying historical logs when you just need 'what's it doing right now.'

When should I use save_attributes instead of logging sensor readings? +

Use this tool to store static or semi-static metadata, not time-series data. Attributes cover details like firmware version, location coordinates, or owner name for an entity. Telemetry handles the fluctuating values (temperature, pressure) over time.

What credentials are required to initialize the ThingsBoard connection for any tool? +

You must provide a valid ThingsBoard Host URL and an API Key during setup. These two pieces of information authenticate your agent with your specific instance, ensuring it can manage devices in your account space. Without them, no tool will work.

How do I use complex filters in find_entities to narrow down asset searches? +

You pass structured filter criteria beyond a simple ID search. You can combine multiple conditions—for example, finding all assets that are 'Critical' AND have the tag 'Warehouse B.' This lets you drill down into specific groups of equipment.

Can I check the latest sensor readings for a specific device? +

Yes. Use the get_telemetry tool by providing the entity type and ID. The agent will return the most recent time-series data points recorded for that device.

Is it possible to trigger a physical action on a device, like turning on a light? +

Absolutely. You can use send_oneway_rpc for simple commands or send_twoway_rpc if you need to wait for a confirmation response from the device hardware.

How do I find all devices that currently have active critical alarms? +

You can use the find_alarms tool with a query body specifying the severity as 'CRITICAL' and status as 'ACTIVE_UNACK' or 'ACTIVE_ACK'.

Connect to your AI in seconds.

Find alarms

Find entities

Get telemetry

ThingsBoard: 7 Tools for Industrial IoT Management

Make your AI actually useful.

Find Alarms

Find Entities

Get Telemetry

Save Attributes

Save Telemetry

Send Oneway Rpc

Send Twoway Rpc

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Debugging device failures shouldn't require jumping through five different vendor dashboards.

ThingsBoard MCP Server: Run full lifecycle IoT control from your chat.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Investigating an unexpected temperature spike

Performing a routine system diagnostic

Auditing critical operational failures

Updating asset metadata after maintenance

The honest tradeoffs

Manually checking device status

Guessing which asset is affected

Forgetting to confirm a command

When It Fits, When It Doesn't

Questions you might have