Mbotmcp
About
control your mbot2 with a power combo: mqtt+mcp+llm
Details
- Author
- deemkeen
- GitHub stars
- 6
- Downloads
- 300
- Categories
- Other
Jump to
- Exposes seven robot commands as MCP tools
- Uses MQTT broker for reliable message passing
- Supports natural language control via any MCP-compatible AI client
- Includes a pre-configured Docker Compose for the MQTT broker
- Provides a Python script for the mBot2 with configurable WiFi and MQTT
- Integrates easily with Spring AI’s @Tool annotation
- Tested with the “beep” command and blue LED lights
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
MbotmcpCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
First, set up an MQTT broker (e.g., with the included Docker Compose file), configure the required environment variables (MQTT_USERNAME, MQTT_PASSWORD, MQTT_SERVER_URI), and upload the mbot-mqtt.py Python script to your mBot2 after editing its WiFi/MQTT settings. Then build the Spring Boot application with mvn clean package and run the test client with mvn test -Dtest=ClientStdioTest. Finally, connect an LLM client that supports MCP (such as Goose) to the server to send natural language commands to the robot.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"mbotmcp": {
"mbotmcp": {
"command": "path-to-java-executable",
"args": [
"-jar",
"/path-to-repo/mbotmcp/target/mbotmcp-0.0.1-SNAPSHOT.jar"
],
"env": {
"MQTT_USERNAME": "<mqtt server username>",
"MQTT_PASSWORD": "<mqtt server password>",
"MQTT_SERVER_URI": "mqtt server url"
}
}
}
}
}McpServers
{
"mbotmcp": {
"command": "path-to-java-executable",
"args": [
"-jar",
"/path-to-repo/mbotmcp/target/mbotmcp-0.0.1-SNAPSHOT.jar"
],
"env": {
"MQTT_USERNAME": "<mqtt server username>",
"MQTT_PASSWORD": "<mqtt server password>",
"MQTT_SERVER_URI": "mqtt server url"
}
}
}MBotMcp
https://github.com/user-attachments/assets/a11d68c5-dc52-4dab-9741-bc1cf47e2ec9
This project demonstrates how to control an mBot2 robot using Spring AI and Model Context Protocol (MCP).
With this setup, AI models can control a physical robot through simple natural language commands like "explore" or "turn left".
Overview
The system consists of:
1. A Spring Boot application that implements the Model Context Protocol
2. An MQTT broker for message passing
3. Python code running on the mBot2 robot
4. AI client integration capabilities
The Spring application exposes robot control commands as AI-callable functions,
allowing AI models to control the physical robot through natural language.
Prerequisites
- Java 21
- Maven
- mBot2 robot and mBlock IDE
- MQTT broker (can run in Docker)
- Basic Java knowledge
Setup Instructions
1. MQTT Broker Setup (Optional, if you don't have one)
Run the included Docker Compose file to set up the MQTT broker:
cd mbotmcp/assets
docker-compose up -d
This creates a message queue that will relay commands between your app and robot.
2. Configure Spring Boot Application
Set the following environment variables:
MQTT_USERNAME=your_username # leave blank if not configured
MQTT_PASSWORD=your_password # leave blank if not configured
MQTT_SERVER_URI=tcp://your_server:1883
These tell your app how to connect to the MQTT broker.
3. mBot2 Setup
To upload the Python script to your mBot2:
1. Connect your mBot2 to your computer via USB
2. Open the mBlock IDE on your computer
3. Click on the "File" menu and select "Open"
4. Navigate to the /assets directory in the repository
5. Open the mbot-mqtt.py file
6. Modify the script to include your personal WiFi and MQTT configurations:
ssid = "<your wifi ssid>"
ssid_password = "<your wifi password>"
mqtt_ip = "<ip of the mqtt broker>"
mqtt_port = 1883
mqtt_user = "<your mqtt username>"
mqtt_password = "<your mqtt password>"
7. Upload the script to your mBot2
8. Power on your mBot2
4. Build the Spring Boot App
mvn clean package
Testing the Setup
1. Ensure your MQTT broker is running
2. Power on your mBot2 and ensure it's connected to WiFi
3. Run the test client:
mvn test -Dtest=ClientStdioTest
4. Watch your robot perform the "beep" command with blue LED lights!
Available Robot Commands
The BotService class defines all the MCP tools, your robot can understand:
- mbotExplore() - Execute the 'explore' routine
- mbotStop() - Stop the robot
- mbotBeep() - Make the robot beep
- mbotLeft() - Turn the robot left
- mbotRight() - Turn the robot right
- mbotForward() - Move the robot forward
- mbotBackward() - Move the robot backward
Integration with AI Models
Once everything is working, you can integrate with LLM clients that support MCP.
Personally, I would recommend Goose for this purpose.
Just point these clients to your server, and they can autonomously control your robot based on natural language requests.
Example natural language commands:
- "Explore the room"
- "Turn right and go forward"
- "Make a beep sound"
How It Works
1. The Spring application exposes robot commands as tools using the @Tool annotation
2. The MCP server in Spring connects these tools to the outside world
3. When an AI wants to control your robot, it calls these methods through the protocol
4. Commands are sent via MQTT to the robot
5. The robot executes the commands based on the received message
Disclaimer
If your robot starts planning world domination, the author accepts no responsibility.
Just unplug it and run! 😂
License
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
