How to connect ChatGPT with your machines

Talk to your machines: How the MCP protocol is revolutionizing AI for connected machines and devices

LLM tools are one of the most used interfaces by companies to connect and simplify the interaction between users and their applications. Today, this is also possible with physical machines and devices. But how is it possible to connect LLMs to machines? Through the Model Context Protocol (MCP).

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is a new open-source standard, developed by Anthropic, that allows large language models (like Claude, ChatGPT, or other LLMs) to dynamically interact with local software, resources, and databases, APIs, and physical devices. In simple terms, MCP is a standardized "translator" that enables LLMs to communicate and interact with external systems in a secure and controlled manner. On one hand, it connects an AI model (the "brain"), and on the other, it allows us to connect anything, including connected machines and physical devices. For IoT devices, this communication relies on an intermediate backend. For example, devices communicate with the backend via MQTT, while the MCP communicates with the backend.

The goal of MCP is to transform AI into an active agent capable of performing tasks and producing higher quality responses. We must remember that although the general capability of models (understood as reliability in solving complex tasks) doubles every seven months, a simple AI model is only able to provide responses limited to its training data, isolated from company data.

Source: BCG, AI Agents, and the Model Context Protocol. AI Platforms Group Briefing Tom Martin, David Heurtaux, Kiran Ikram, Dan Sack, Djon Kleine, Niels Degrande, Aprile 2025, https://www.rivista.ai/2025/04/28/bcg-revela-il-futuro-degli-agenti-autonomi-e-dei-protocolli-che-li-sostengono-perche-non-e-solo-lia-ma-gli-agenti-ia-a-cambiare-il-gioco/

Why is MCP revolutionary when paired with traditional LLMs?

To understand the MCP revolution, we need to take a step back.

“Original” LLMs are based on predicting the next token by simply generating text from an input. They have now evolved into conversational models capable of interacting with the user and integrating into structured workflows. Starting as chatbots trained to follow instructions and generate coherent responses, they have been integrated into operational architectures using predefined logic.

Today, we are witnessing an evolution towards more advanced forms of autonomous agents and, in the future, collaborative multi-agent systems. We are thus moving from a deterministic logic based on if-statements to agents that can observe the environment, plan, and act independently, leveraging external resources.

Agentic workflows use a technique called prompt chaining: a task is broken down into a series of steps, in which each output from an LLM is passed to the next step. The process is linear, and each step includes explicit checks (logic gates) that decide whether to proceed with the flow. In contrast, autonomous agents operate in a cyclical and adaptive manner. They receive a goal from a user and, through a call to the LLM, begin to plan and reason autonomously. The agent performs an action, observes its effect, receives feedback from the context or other users, and uses this information to update its behavior in subsequent iterations until the task is complete.

In the future, this paradigm will enable the emergence of multi-agent systems, where multiple autonomous agents collaborate, exchange information, and coordinate to achieve shared goals. Although still in its early stages, these intelligent ecosystems will no longer follow a static sequence but will make decisions in real-time and in a coordinated way, based on what they learn.

Source: BCG, AI Agents, and the Model Context Protocol. AI Platforms Group Briefing Tom Martin, David Heurtaux, Kiran Ikram, Dan Sack, Djon Kleine, Niels Degrande, Aprile 2025, https://www.rivista.ai/2025/04/28/bcg-revela-il-futuro-degli-agenti-autonomi-e-dei-protocolli-che-li-sostengono-perche-non-e-solo-lia-ma-gli-agenti-ia-a-cambiare-il-gioco/

How is the Model Context Protocol structured?

The MCP is structured in a client-server architecture composed of:

• MCP Host which receives the user's request, meaning local AI applications (e.g., editors like Claude Desktop, Cursor) or cloud-hosted systems (like OpenAI (ChatGPT), Anthropic Claude). Its role is to coordinate interactions with the artificial intelligence models (LLMs) and to manage connections with various data sources and tools through the MCP Clients.

• MCP Client: Acts as a "bridge". It is a component, managed by the Host, that establishes a direct, 1-to-1 connection with an MCP Server. The Host uses the Client to communicate with the Server and access the capabilities that the latter offers.

• MCP Server, which exposes tools and data via API to clients.

• Local data sources or online services, meaning files, databases, and computer services or external online services (for example, via API) to which MCP servers can connect.

Source: https://modelcontextprotocol.io/introduction

How does an application that uses MCP work?

• User input: The user or the application provides an instruction. This request is sent to the MCP client.

• MCP server identification: The LLM is queried to determine which MCP Server (i.e., which corporate backend) is best suited to handle this request.

• Retrieval of available tools: The MCP client contacts the selected server and retrieves the list of tools that the agent can use. For example: running a query on a database, updating a record.

• Choice of tool and parameters: The LLM determines which specific tool to use and with which parameters.

• Task execution: The MCP Server executes the requested action—securely calling the appropriate API. Alternatively, the flow can include an optional validation step with the user before performing the action.

Regarding security, the MCP protocol provides for the use of OAuth to communicate between the client and server. OAuth is a security protocol that allows third-party applications (the MCP client in this case) to access user resources without the user having to give their password to the third-party application. Users can decide to provide their authorization just once or to approve each individual action.

The implementation of MCP on Things5

To learn more about the implementation of the Model Context Protocol (MCP) on the Things5 platform, we spoke with Andrea Grossetti, the team's Senior Frontend Developer. Andrea shared with us practical examples of how the protocol has been integrated to intelligently manage connected machines and devices.

Creating one's own MCP Server is relatively simple: all that's needed are well-defined APIs and a coherent tool structure. However, as Andrea confirms, the technology is still in an evolutionary phase, and the online documentation does not always offer complete examples.

One of the most appreciated advantages of MCP is its "driveability": each tool can be described clearly and in detail, indicating to the AI model when and why to use it. This allows the LLM to make autonomous yet coherent decisions, based on the context and the end-user's goals.

Security is certainly a central aspect. All tools and APIs exposed via MCP are protected by OAuth authentication, ensuring that only authorized users can perform actions or access sensitive data. Specifically, the Things5 MCP server leverages keycloak to manage authorizations and permissions.

Furthermore, the accessibility levels are perfectly aligned with the authorization system already present on Things5, ensuring native integration without compromises in terms of cybersecurity and privacy.

To add the Things5 MCP server on Claude or other AI tools, simply add the MCP server's address from the Connectors section:

The Things5 Model Context Protocol has 24 different tools that allow the LLM to:

• Identify the list of machines
• Read parameters from a device
• Update firmware in real-time
• Add users to machine groups
• Query aggregated metrics
• Create new devices or firmware versions
  

Use cases

Firmware Update

With the integration of the Model Context Protocol (MCP) into the Things5 platform, updating the firmware of a connected device is simple, secure, and fully automated. The user can send the request directly through conversational AI interfaces, such as ChatGPT, Copilot, or other MCP-compatible agents. For example, the user can request an update for a specific device.

• The MCP Client receives the user's request.

• The most suitable MCP Server is automatically selected to handle the operation.

• The server retrieves the necessary tools (e.g., device list, available firmware).

• The AI agent performs a sequence of autonomous actions:

• Identifies the correct device
• Verifies compatibility and availability of the firmware version
• Performs the update securely
• Monitors the status in real-time

Thanks to the native support for OAuth and the Things5 permissions system, all operations are traceable, protected, and customized based on the user's profile.

Searching for available machine parameters

The AI interacts with the MCP tools in the following order:

• It retrieves the device list with list_machines .
• It reads the entire technical configuration via  read_parameters.
• It filters and returns only the data related to the indicated machine.

A detailed section is provided with the main parameters (delays, minimum times, power on/off), organized by technical category and explained in natural language.

Reading a technical parameter

The AI agent activates the MCP tools in sequence to:

• Identify the corresponding device (via list_machines ).
• Retrieve the value of the specific parameter ( read_single_parameter ).

The value is returned instantly with full traceability and in compliance with the permissions defined on Things5.

Why is it important for those who build machines and devices?

For builders of machines and IoT systems, MCP represents a paradigm shift:

• Reduced technical load: it is no longer necessary to build complex user interfaces or manually integrate each API.

• Automated user support: the AI can answer technical requests ("what is the value of parameter X for machine model Y?") in natural language.

• Operational control: firmware, parameters, device groups, and users can be managed directly via prompt.

Discover how to let customers talk with your connected products via ChatGPT or Claude, in just a few minutes and effortlessly.