{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-thingsboard","slug":"thingsboard","name":"ThingsBoard","type":"mcp","url":"https://github.com/thingsboard/thingsboard-mcp","page_url":"https://unfragile.ai/thingsboard","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-thingsboard__cap_0","uri":"capability://tool.use.integration.natural.language.to.thingsboard.rest.api.translation","name":"natural language to thingsboard rest api translation","description":"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.","intents":["I want my AI assistant to control IoT devices using plain English commands","I need to query device telemetry and alarms through conversational prompts","I want to automate ThingsBoard operations without writing REST API code"],"best_for":["IoT platform operators integrating AI agents with ThingsBoard","Teams building conversational interfaces for device management","Developers deploying LLM-driven IoT automation without API expertise"],"limitations":["Requires active ThingsBoard instance with network connectivity","MCP protocol overhead adds latency compared to direct REST calls","Natural language interpretation depends on LLM quality — ambiguous commands may fail","No built-in caching of API responses — each query hits ThingsBoard REST API"],"requires":["ThingsBoard instance (CE, PE, Cloud, or Edge)","Valid ThingsBoard credentials (username/password or API token)","MCP-compatible client (Claude Desktop, Cursor, or custom MCP host)","Java 11+ for JAR deployment or Docker for containerized deployment","Network access from MCP server to ThingsBoard instance"],"input_types":["natural language text prompts","structured MCP tool call requests with JSON parameters"],"output_types":["JSON-structured tool responses","Device/asset/telemetry data in JSON format","Operation status confirmations"],"categories":["tool-use-integration","natural-language-interface"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_1","uri":"capability://tool.use.integration.device.lifecycle.management.through.natural.language","name":"device lifecycle management through natural language","description":"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.","intents":["I want to create a new IoT device and assign it to a customer using voice commands","I need to update device attributes and credentials programmatically through an AI agent","I want to list all devices matching certain criteria without writing SQL queries"],"best_for":["IoT operations teams managing large device fleets through AI interfaces","Developers building device onboarding workflows with LLM assistance","Non-technical users provisioning devices through conversational AI"],"limitations":["Bulk device operations require iterative tool calls — no batch API endpoint exposed","Device attribute validation depends on ThingsBoard schema configuration","Credential rotation and key management require manual follow-up API calls","No transactional guarantees — partial failures in multi-step device setup require manual rollback"],"requires":["ThingsBoard instance with Device Management API enabled","User account with DEVICE_ADMIN or equivalent permissions","Valid device type definitions pre-configured in ThingsBoard"],"input_types":["natural language device specifications","JSON device configuration objects"],"output_types":["Device entity objects with UUID, name, type, attributes","Credential tokens and access keys","Operation status and error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_10","uri":"capability://tool.use.integration.tool.schema.generation.and.mcp.discovery.protocol","name":"tool schema generation and mcp discovery protocol","description":"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.","intents":["I want my LLM client to automatically discover all available ThingsBoard operations","I need tool schemas that describe parameters, types, and expected responses","I want the MCP server to validate tool parameters before executing API calls"],"best_for":["Developers building MCP clients that need tool discovery","Teams integrating LLMs with ThingsBoard through MCP protocol","Organizations standardizing on MCP for AI-tool integration"],"limitations":["Schema generation happens at server startup — dynamic tool registration not supported","Parameter validation limited to JSON schema constraints — complex validation logic requires custom implementation","Schema updates require server restart — cannot add tools without downtime","Tool descriptions depend on developer documentation — may be incomplete or inaccurate"],"requires":["MCP-compatible client that supports tool discovery","Tool implementations with proper schema annotations"],"input_types":["Tool implementation metadata","Parameter type definitions"],"output_types":["JSON schema definitions","MCP tool discovery responses","Tool parameter validation results"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_11","uri":"capability://automation.workflow.spring.boot.application.deployment.with.docker.and.jar.packaging","name":"spring boot application deployment with docker and jar packaging","description":"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.","intents":["I want to deploy ThingsBoard MCP as a Docker container in Kubernetes","I need to run the MCP server as a standalone JAR with custom configuration","I want to configure the MCP server using environment variables"],"best_for":["DevOps teams deploying MCP servers in containerized environments","Developers running MCP servers locally for development and testing","Organizations deploying MCP in cloud platforms (AWS, Azure, GCP)"],"limitations":["Docker image size may be large due to Java runtime — not suitable for serverless functions","JAR deployment requires Java 11+ runtime — cannot run on systems without Java","Configuration via environment variables may be cumbersome for complex setups","No built-in clustering or horizontal scaling — requires external load balancing"],"requires":["Java 11+ for JAR deployment","Docker for containerized deployment","Spring Boot 2.7+ (implicit in MCP server)","Valid application.properties or environment variables for configuration"],"input_types":["application.properties configuration files","environment variables","Docker build arguments"],"output_types":["Executable JAR files","Docker container images","Application startup logs"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_12","uri":"capability://automation.workflow.comprehensive.logging.and.diagnostic.capabilities","name":"comprehensive logging and diagnostic capabilities","description":"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.","intents":["I need to debug why a tool call is failing with a cryptic error message","I want to see the actual API requests and responses being sent to ThingsBoard","I need to troubleshoot authentication issues between the MCP server and ThingsBoard"],"best_for":["Developers debugging MCP server integration issues","Operations teams troubleshooting production MCP deployments","Teams investigating API communication problems"],"limitations":["Verbose logging may expose sensitive information (credentials, tokens) — requires careful log management","High log volume in DEBUG mode may impact performance","Log retention depends on external log management — no built-in log rotation","Diagnostic logging requires manual configuration — not enabled by default"],"requires":["Access to MCP server logs (stdout, files, or log aggregation system)","Ability to modify logging configuration (application.properties or logback.xml)"],"input_types":["Logging configuration parameters","Log level specifications"],"output_types":["Structured log messages","API request/response logs","Error stack traces","Diagnostic information"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_2","uri":"capability://search.retrieval.asset.and.entity.relationship.querying.with.natural.language.filters","name":"asset and entity relationship querying with natural language filters","description":"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.","intents":["I want to find all assets in a building with temperature above 25 degrees","I need to list all devices related to a specific customer with their latest telemetry","I want to query entities matching multiple conditions and sort by timestamp"],"best_for":["IoT analysts querying device data through conversational interfaces","Developers building intelligent dashboards with LLM-powered search","Operations teams investigating device anomalies through natural language queries"],"limitations":["Query complexity limited by natural language parsing — very complex nested conditions may fail","Pagination requires explicit limit/offset parameters — no automatic result streaming","Filter types depend on ThingsBoard attribute types — custom types may not be supported","Relationship queries limited to direct relations — multi-hop traversal requires multiple queries"],"requires":["ThingsBoard instance with Entity Data Query API enabled","User account with READ permissions on target entities","Entity attributes and relations pre-configured in ThingsBoard"],"input_types":["natural language query descriptions","structured filter objects with field names and operators"],"output_types":["Paginated entity result sets with attributes","Relationship graph data","Aggregated counts and statistics"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_3","uri":"capability://data.processing.analysis.telemetry.data.retrieval.and.time.series.analysis","name":"telemetry data retrieval and time-series analysis","description":"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.","intents":["I want to get the average temperature readings from a device over the last 24 hours","I need to retrieve all telemetry data points for a sensor between two specific dates","I want to compare telemetry metrics across multiple devices in natural language"],"best_for":["IoT data analysts performing time-series analysis through conversational interfaces","Operations teams investigating historical device behavior","Developers building AI-powered anomaly detection systems"],"limitations":["Aggregation functions limited to built-in ThingsBoard metrics (min, max, avg, sum)","Large time ranges may return massive datasets — no automatic sampling or downsampling","Telemetry retention depends on ThingsBoard configuration — historical data may be pruned","No streaming support — all data returned in single response, not suitable for real-time monitoring"],"requires":["ThingsBoard instance with Telemetry API enabled","User account with READ permissions on target devices/assets","Telemetry data already collected and stored in ThingsBoard"],"input_types":["natural language time range descriptions (e.g., 'last 24 hours', 'between Jan 1 and Jan 31')","device/asset identifiers","telemetry key names"],"output_types":["Time-series data points with timestamps and values","Aggregated metrics (min, max, avg, sum)","JSON arrays of telemetry readings"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_4","uri":"capability://tool.use.integration.alarm.and.event.management.through.conversational.commands","name":"alarm and event management through conversational commands","description":"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.","intents":["I want to acknowledge all critical alarms for a specific device","I need to create an alarm for a device that exceeds a temperature threshold","I want to list all unresolved alarms from the last hour sorted by severity"],"best_for":["IoT operations teams managing device alerts through AI assistants","Developers building intelligent alerting systems with LLM-driven acknowledgment","Non-technical users responding to device alarms through conversational interfaces"],"limitations":["Alarm creation requires pre-configured alarm rules in ThingsBoard — cannot create arbitrary alarms","Bulk alarm operations (acknowledge multiple) require iterative tool calls","Alarm severity levels depend on ThingsBoard configuration — custom severities may not be supported","No alarm escalation or routing logic — handled separately by ThingsBoard rules engine"],"requires":["ThingsBoard instance with Alarm API enabled","User account with ALARM_ADMIN or equivalent permissions","Alarm rules pre-configured in ThingsBoard"],"input_types":["natural language alarm commands","alarm identifiers and device references","severity and status filters"],"output_types":["Alarm entity objects with status, severity, timestamps","Paginated alarm lists","Operation confirmations"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_5","uri":"capability://tool.use.integration.customer.and.user.account.management.via.natural.language","name":"customer and user account management via natural language","description":"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.","intents":["I want to create a new customer account and assign devices to them","I need to update a user's permissions and role assignments","I want to list all users in a customer account with their current permissions"],"best_for":["IoT platform administrators managing multi-tenant deployments","Developers building customer onboarding workflows with AI assistance","Operations teams managing user access control through conversational interfaces"],"limitations":["User role definitions are fixed in ThingsBoard — cannot create custom roles through MCP","Bulk user operations require iterative tool calls — no batch user creation","Permission inheritance depends on ThingsBoard hierarchy — complex permission scenarios may require manual configuration","Password reset and credential rotation require separate ThingsBoard operations"],"requires":["ThingsBoard instance with User Management API enabled","User account with ADMIN or CUSTOMER_ADMIN permissions","Pre-configured customer hierarchies in ThingsBoard"],"input_types":["natural language user/customer specifications","email addresses and role names","permission and access control parameters"],"output_types":["User and customer entity objects","Permission and role assignment confirmations","User lists with role information"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_6","uri":"capability://tool.use.integration.entity.relationship.mapping.and.traversal","name":"entity relationship mapping and traversal","description":"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.","intents":["I want to create a relationship showing that a device belongs to a specific asset","I need to find all devices related to a customer through a chain of relationships","I want to delete a relationship between two entities using natural language"],"best_for":["IoT architects designing entity hierarchies through conversational interfaces","Developers building dynamic device-asset-customer mappings","Operations teams managing complex IoT infrastructure relationships"],"limitations":["Relation types must be pre-defined in ThingsBoard — cannot create arbitrary relation types through MCP","Multi-hop relationship queries require multiple API calls — no built-in graph traversal","Relationship validation depends on ThingsBoard configuration — invalid relationships may be rejected","No transactional guarantees for multi-step relationship creation"],"requires":["ThingsBoard instance with Relation API enabled","User account with appropriate permissions for target entities","Pre-configured relation types in ThingsBoard"],"input_types":["natural language relationship descriptions","entity identifiers (device IDs, asset IDs, customer IDs)","relation type names"],"output_types":["Relationship entity objects","Related entity lists","Operation confirmations"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_7","uri":"capability://tool.use.integration.mcp.protocol.communication.with.dual.transport.modes","name":"mcp protocol communication with dual transport modes","description":"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.","intents":["I want to connect my LLM client to ThingsBoard using the standard MCP protocol","I need to deploy ThingsBoard MCP in a containerized environment with HTTP/SSE transport","I want to use the same MCP server with multiple different LLM clients"],"best_for":["Developers integrating ThingsBoard with MCP-compatible LLM clients","Teams deploying LLM-IoT integrations in containerized environments","Organizations standardizing on MCP protocol for AI-tool integration"],"limitations":["STDIO mode requires direct process spawning — not suitable for remote deployments","HTTP/SSE mode adds network latency compared to STDIO","MCP protocol overhead adds ~50-200ms per tool call vs direct API access","Tool discovery happens at connection time — dynamic tool registration not supported"],"requires":["MCP-compatible client (Claude Desktop, Cursor, or custom MCP host)","Java 11+ for JAR deployment or Docker for containerized deployment","Network connectivity between MCP client and server (for HTTP/SSE mode)"],"input_types":["MCP JSON-RPC tool call requests","MCP protocol initialization messages"],"output_types":["MCP JSON-RPC tool responses","MCP protocol messages","Tool schema definitions"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_8","uri":"capability://tool.use.integration.edition.aware.capability.filtering.for.ce.vs.pe.thingsboard","name":"edition-aware capability filtering for ce vs pe thingsboard","description":"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.","intents":["I want to deploy a single MCP server that works with both CE and PE ThingsBoard instances","I need my LLM to automatically adapt its capabilities based on the ThingsBoard edition","I want to avoid errors when using PE-only features on a CE instance"],"best_for":["Organizations running mixed ThingsBoard editions (CE and PE)","Developers building multi-tenant MCP deployments","Teams migrating from CE to PE without changing MCP configuration"],"limitations":["Edition detection happens at connection time — cannot switch editions without reconnection","PE-only features silently unavailable in CE — no explicit error messages to users","Feature parity between editions may change with ThingsBoard updates — requires MCP server updates","No graceful degradation — PE-only tool calls fail if attempted on CE instance"],"requires":["ThingsBoard instance with accessible edition information via REST API","User account with sufficient permissions to query edition details"],"input_types":["ThingsBoard connection parameters","Edition detection queries"],"output_types":["Filtered tool schema definitions","Edition-specific capability lists"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-thingsboard__cap_9","uri":"capability://safety.moderation.jwt.authentication.and.credential.management.for.thingsboard.api.access","name":"jwt authentication and credential management for thingsboard api access","description":"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.","intents":["I want the MCP server to automatically authenticate with ThingsBoard using stored credentials","I need JWT tokens to be refreshed automatically without interrupting tool execution","I want to securely manage ThingsBoard credentials in the MCP server configuration"],"best_for":["Developers deploying MCP servers with automated ThingsBoard authentication","Teams managing long-running MCP deployments requiring token refresh","Operations managing credential rotation for ThingsBoard access"],"limitations":["Credentials stored in configuration files or environment variables — requires secure secret management","Token caching in memory — lost on server restart, requires re-authentication","No support for OAuth2 or other advanced authentication methods — only username/password","Token expiration handling may cause brief request failures during refresh"],"requires":["ThingsBoard instance with REST API authentication enabled","Valid ThingsBoard username and password or API token","Secure credential storage mechanism (environment variables, secret manager, etc.)"],"input_types":["ThingsBoard credentials (username/password)","API token strings"],"output_types":["JWT tokens","Authentication status","Token refresh confirmations"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":33,"verified":false,"data_access_risk":"high","permissions":["ThingsBoard instance (CE, PE, Cloud, or Edge)","Valid ThingsBoard credentials (username/password or API token)","MCP-compatible client (Claude Desktop, Cursor, or custom MCP host)","Java 11+ for JAR deployment or Docker for containerized deployment","Network access from MCP server to ThingsBoard instance","ThingsBoard instance with Device Management API enabled","User account with DEVICE_ADMIN or equivalent permissions","Valid device type definitions pre-configured in ThingsBoard","MCP-compatible client that supports tool discovery","Tool implementations with proper schema annotations"],"failure_modes":["Requires active ThingsBoard instance with network connectivity","MCP protocol overhead adds latency compared to direct REST calls","Natural language interpretation depends on LLM quality — ambiguous commands may fail","No built-in caching of API responses — each query hits ThingsBoard REST API","Bulk device operations require iterative tool calls — no batch API endpoint exposed","Device attribute validation depends on ThingsBoard schema configuration","Credential rotation and key management require manual follow-up API calls","No transactional guarantees — partial failures in multi-step device setup require manual rollback","Schema generation happens at server startup — dynamic tool registration not supported","Parameter validation limited to JSON schema constraints — complex validation logic requires custom implementation","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.050Z","last_scraped_at":"2026-05-03T14:00:15.503Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=thingsboard","compare_url":"https://unfragile.ai/compare?artifact=thingsboard"}},"signature":"b5OeMjoTK+cpszjLeg3abJxJp/fboUOMIrWeiPT6FCROkBmR8EvIfVmAANEMbr2pKuotX+1+l8gYcxxkFRQQBA==","signedAt":"2026-06-22T12:34:51.941Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/thingsboard","artifact":"https://unfragile.ai/thingsboard","verify":"https://unfragile.ai/api/v1/verify?slug=thingsboard","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}