ThingsBoard

Translates conversational AI commands into structured ThingsBoard REST API operations through a Spring Boot MCP server that parses natural language intent, maps it to tool schemas, and executes authenticated API calls. The server acts as a semantic bridge between LLM outputs and IoT platform operations, handling JWT authentication, request serialization, and response transformation without requiring users to write API code directly.

Exposes device CRUD operations (create, read, update, delete) and state management via MCP tools that accept natural language parameters and translate them to ThingsBoard Device API calls. Handles device provisioning, attribute assignment, and credential management through a tool callback provider that validates inputs and manages JWT-authenticated API requests to the ThingsBoard REST endpoint.

Generates MCP-compliant tool schemas that describe available tools, their parameters, and expected outputs, enabling LLM clients to discover and understand tool capabilities through the MCP discovery protocol. The implementation uses a Tool Callback Provider pattern that introspects tool implementations and generates JSON schemas that conform to MCP specifications, allowing LLMs to invoke tools with proper parameter validation.

Packages ThingsBoard MCP as a Spring Boot application deployable via Docker containers or standalone JAR files with configurable application properties. The implementation uses Spring Boot's auto-configuration and property binding to enable deployment flexibility, supporting both containerized cloud deployments and traditional JAR-based installations with environment-based configuration.

Provides configurable logging at multiple levels (DEBUG, INFO, WARN, ERROR) with diagnostic output for troubleshooting MCP server issues, API communication, and authentication problems. The implementation uses Spring Boot's logging framework with configuration options for log levels, output formats, and diagnostic logging that helps developers understand request/response flows and identify integration issues.

Enables querying of ThingsBoard assets and entity relationships through a sophisticated Entity Data Query (EDQ) system that translates natural language filter expressions into structured query objects. The system supports complex filtering (equality, range, text search, regex), sorting, pagination, and relationship traversal through a query builder that constructs REST API payloads without exposing SQL or API syntax to users.

Exposes ThingsBoard telemetry APIs through MCP tools that retrieve time-series data for devices and assets with natural language time range specifications and aggregation options. The implementation handles timestamp parsing, data point filtering, and metric aggregation (min, max, avg, sum) through a Telemetry Tool that translates conversational requests into ThingsBoard REST API calls with proper JWT authentication and response formatting.

Exposes ThingsBoard alarm lifecycle operations (create, acknowledge, clear, delete) and querying through MCP Alarm Tools that translate natural language commands into REST API calls. The implementation handles alarm state transitions, severity filtering, and temporal queries through a tool callback provider that validates alarm parameters and manages JWT-authenticated requests to ThingsBoard's Alarm API endpoint.

Exposes ThingsBoard customer and user management operations through MCP tools that handle account creation, permission assignment, and credential management via natural language commands. The implementation translates conversational requests into REST API calls that manage user hierarchies, role assignments, and access control through a tool callback provider with JWT authentication and validation of user permissions.

Exposes ThingsBoard relation APIs through MCP tools that create, query, and delete relationships between entities (devices, assets, customers) using natural language descriptions. The implementation translates conversational relationship specifications into REST API calls that manage entity graphs, enabling users to express complex relationships (e.g., 'device belongs to asset') without understanding ThingsBoard's relation type system or API syntax.

Implements the Model Context Protocol (MCP) as a Spring Boot application supporting both STDIO and HTTP/SSE transport modes, enabling integration with diverse MCP clients (Claude Desktop, Cursor, custom hosts). The server handles MCP JSON-RPC message serialization, tool discovery, and request routing through a configurable transport layer that abstracts protocol details from tool implementations.

Dynamically exposes different tool sets based on ThingsBoard edition (Community vs Professional) through an Edition-Aware Tool Provider that detects the connected instance type and filters available tools accordingly. The implementation queries ThingsBoard's edition information at connection time and conditionally registers tools (e.g., Entity Groups only in PE) without requiring separate deployments or configuration files.

Manages JWT token acquisition and refresh for ThingsBoard REST API authentication through a RestClientService that handles login, token caching, and automatic re-authentication on token expiration. The implementation abstracts authentication complexity from tool implementations, enabling tools to make authenticated API calls without managing credentials or token lifecycle directly.