Content
# Nonead Universal-Robots MCP Server
<div align="center">
<a href="https://www.nonead.com">
<img src="https://www.nonead.com/assets/img/vi/NONEAD_ai.png" width="300" alt="nonead logo">
</a>
</div>
<p align="center">
<a href="./README.en.md">English</a> |
<a href="./README.md">简体中文</a> |
<a href="./README.jp.md">日本語</a> |
<a href="./README.ko.md">한국어</a> |
<a href="./README.de.md">Deutsch</a> |
<a href="./README.fr.md">Français</a> |
<a href="./README.ru.md">Русский язык</a> |
<a href="./README.th.md">ภาษาไทย</a> |
<a href="./README.es.md">Español</a> |
<a href="./README.ar.md">العربية</a> |
<a href="./README.da.md">dansk</a>
</p>
<p align="center">
<a href='https://gitee.com/nonead/Nonead-Universal-Robots-MCP/releases'>
<img src='https://img.shields.io/github/v/release/nonead/Nonead-Universal-Robots-MCP.svg?label=Gitee%20Release&color=blue' alt="Gitee Release"></img>
</a>
<a href="https://github.com/nonead/Nonead-Universal-Robots-MCP/releases">
<img src="https://img.shields.io/github/v/release/nonead/Nonead-Universal-Robots-MCP.svg?label=GitHub%20Release" alt="GitHub Release"></img>
</a>
<a href='https://www.python.org/downloads/'>
<img src='https://img.shields.io/pypi/pyversions/RPALite'></img>
</a>
<a href='https://www.universal-robots.cn'>
<img src='https://img.shields.io/badge/PolyScope-3.x_&_5.x-71A8CF'></img>
</a>
<a href="https://gitee.com/nonead/Nonead-Universal-Robots-MCP/wikis/pages">
<img src="https://img.shields.io/badge/User%20Guide-1e8b93?logo=readthedocs&logoColor=f5f5f5" alt="User Guide"></img>
</a>
<a href="./LICENSE">
<img height="20" src="https://img.shields.io/badge/License-User_Segmented_Dual_Licensing-blue" alt="license"></img>
</a>
<a href="https://gitee.com/nonead/Nonead-Universal-Robots-MCP">
<img height="20" src="https://gitee.com/nonead/Nonead-Universal-Robots-MCP/badge/fork.svg?theme=dark" alt="Gitee Forks"></img>
</a>
<a href="https://gitee.com/nonead/Nonead-Universal-Robots-MCP">
<img height="20" src="https://gitee.com/nonead/Nonead-Universal-Robots-MCP/badge/star.svg?theme=dark" alt="Gitee Stars"></img>
</a>
<a href="https://github.com/nonead/Nonead-Universal-Robots-MCP">
<img src="https://img.shields.io/github/forks/nonead/Nonead-Universal-Robots-MCP?label=Forks&style=flat-square" alt="Github Forks"></img>
</a>
<a href='https://github.com/nonead/Nonead-Universal-Robots-MCP'>
<img src="https://img.shields.io/github/stars/nonead/Nonead-Universal-Robots-MCP.svg?style=flat-square&label=Stars&logo=github" alt="Github Stars"/></img>
</a>
</p>
## 1. What is MCP?
MCP (Model Context Protocol) is a communication protocol developed by Anthropic (open-sourced in November 2024), mainly used to enable AI large models (such as DeepSeek-V3-0324, DeepSeek-R1, Qwen3, etc.) to access external data, tools, and services more efficiently, thereby providing more accurate and intelligent answers.
What can MCP do?
Provide context information:
Applications can pass additional information such as files and database content to the AI to help the AI better understand the problem.
For example: Let AI read a report and then answer questions based on the content of the report.
Call external tools:
AI can directly operate local or remote functions through MCP, such as reading and writing files, querying databases, calling APIs, and controlling hardware devices.
For example: Let AI automatically organize your documents, or extract data from the database to generate reports.
Build intelligent workflows:
Developers can combine multiple MCP services to allow AI to complete complex tasks, such as automated data analysis and intelligent customer service.
Ensure data security:
MCP runs locally, avoiding the upload of sensitive data to the cloud and protecting privacy.
## 2. How does MCP work?
MCP adopts a Client-Server architecture:
MCP client: Usually an AI application (such as Claude or other LLM tools) responsible for sending requests to the server.
MCP server: Runs locally or remotely, providing data or tool interfaces for AI to call.
Communication method: Based on JSON-RPC 2.0 (a standard communication format), it supports requests, responses, and real-time notifications.
## 3. Main functions of the MCP server
The MCP server is equivalent to AI's "assistant" and can provide the following support:
Access data (Resource Exposure)
Provide files, databases, memory data, etc., for example:
file:///docs/report.pdf (read local files), db://sales/records (query database), execute operations (Tool Provisioning)
Provide callable functions, for example:
search_database(sql_query) (execute SQL query), save_file(path, content) (save file), real-time update (Dynamic Notification),
When data changes, the server can actively notify AI to ensure the information is up to date, session management (Session Management), manage the connection between AI and the server to ensure stable communication.
## 2. nUR MCP Server Core Functions
Technical description of nUR_MCP_SERVER product independently developed by Nonead
Product Overview:
nUR_MCP_SERVER is an intelligent robot control middleware system built based on the MCP (Model Control Protocol) interface protocol. It realizes natural language interactive control of industrial robots by integrating large language models (LLM). The product adopts a Client-Server architecture design and supports deep integration with the entire series of Universal Robots collaborative robots, which has revolutionized the traditional industrial robot operation paradigm of teaching pendant programming.
Core Technical Architecture:
1. Semantic Parsing Engine
Equipped with a multi-layer Transformer architecture NLP processing module, it supports context-aware instruction parsing (Contextual Command Parsing) and realizes end-to-end conversion from natural language to robot control instructions. The instruction recognition accuracy rate reaches 98.6%
2. Dynamic Script Generation System
Based on the LLM code generation framework, it can automatically convert natural language instructions into URScript robot control scripts, support real-time syntax verification and security verification, and the generation efficiency is 12 times higher than traditional programming.
3. Multi-modal Control Interface
- MCP protocol extension layer: supports TCP/UDP dual-mode communication and provides µs-level instruction response
- Device abstraction layer: realizes standardized access of URCap plug-ins
- Data bus: Based on TCP/IP Ethernet protocol, it realizes multi-machine collaborative control
Core Function Features:
▶ Natural language instant control
Directly drive robot motion (pose control, trajectory planning, IO operation) through voice/text commands, support dynamic parameter injection and real-time motion correction
▶ Intelligent Data Acquisition System
- Real-time acquisition of 12-dimensional status data such as joint torque and end pose
- Supports data filtering rules defined in natural language
- Automatically generate structured data reports (CSV/JSON/XLSX)
▶ Multi-machine Collaborative Control
Based on the distributed task scheduling algorithm, combined with the MCP-Client developed by Nonead, it can simultaneously manage ≤12 UR robot clusters, support voice cascade instructions and cross-device task orchestration
▶ Adaptive Learning Module
The built-in incremental training framework continuously optimizes the instruction-action mapping relationship through user feedback, and the system iterative learning cycle is ≤24h
Technical Indicators:
- Instruction response delay: ＜200ms (end-to-end)
- Protocol compatibility: MCP v2.1+ / URScript v5.0+
- Concurrent processing capability: 200+ TPS
**The following is a table of function classifications for nUR_MCP_SERVER tools (automatically generated from source code):**
| Tool Name | Function Category | Brief Description | Main Parameters |
|--------|----------|----------|----------|
| `connect_ur` | Connection Management | Establish a connection with the UR robot at the specified IP | `ip` |
| `disconnect_ur` | Connection Management | Disconnect from the specified robot | `ip` |
| `get_serial_number` | Device Information | Get the robot serial number | `ip` |
| `get_time` | Status Monitoring | Get the robot's boot time (seconds) | `ip` |
| `get_ur_software_version` | Device Information | Get the Polyscope software version | `ip` |
| `get_robot_model` | Device Information | Get the robot model | `ip` |
| `get_safety_mode` | Device Information | Get the safety mode | `ip` |
| `get_robot_mode` | Status Monitoring | Get the robot running mode | `ip` |
| `get_program_state` | Program Control/Status | Get the current loaded program and execution status | `ip` |
| `get_actual_tcp_pose` | Motion Control | Get the current TCP pose | `ip` |
| `get_actual_joint_pose` | Motion Control | Get the current joint angle | `ip` |
| `get_output_int_register` | Register Operation | Read Int register | `ip, index` |
| `get_output_double_register` | Register Operation | Read Double register | `ip, index` |
| `get_output_bit_register` | Register Operation | Read Bool register | `ip, index` |
| `get_actual_robot_voltage` | Status Monitoring | Get the robot voltage (V) | `ip` |
| `get_actual_robot_current` | Status Monitoring | Get the robot current (A) | `ip` |
| `get_actual_joint_voltage` | Status Monitoring | Get the voltage (V) of each joint | `ip` |
| `get_actual_joint_current` | Status Monitoring | Get the current (A) of each joint | `ip` |
| `get_joint_temperatures` | Status Monitoring | Get the temperature (°C) of each joint | `ip` |
| `get_programs` | Program Control | List the .urp files under `/programs` on the robot (via SSH) | `ip, username, password` |
| `send_program_script` | Program Control | Send and execute real-time script | `ip, script` |
| `movej` | Motion Control | Joint space motion command | `ip, q, a, v, t, r` |
| `movel` | Motion Control | TCP linear motion command | `ip, pose, a, v, t, r` |
| `movel_x` | Motion Control | Move along the X axis (relative) | `ip, distance` |
| `movel_y` | Motion Control | Move along the Y axis (relative) | `ip, distance` |
| `movel_z` | Motion Control | Move along the Z axis (relative) | `ip, distance` |
| `draw_circle` | Motion Control | Draw a circle on the specified plane | `ip, center, r, coordinate` |
| `draw_square` | Motion Control | Draw a square on the specified plane | `ip, origin, border, coordinate` |
| `draw_rectangle` | Motion Control | Draw a rectangle on the specified plane | `ip, origin, width, height, coordinate` |
| `setup_multi_robot_coordination` | Multi-machine Coordination | Register robots and set collaboration mode | `robot_ids, collaboration_mode` |
| `create_collaborative_task` | Multi-machine Coordination | Create collaborative task | `task_name, robot_assignments, dependencies` |
| `execute_collaborative_task` | Multi-machine Coordination | Execute collaborative task | `task_id` |
| `generate_bezier_path` | Trajectory Planning | Generate Bezier curve path based on control points | `control_points, num_points` |
| `optimize_trajectory` | Trajectory Planning | Optimize the given path (time/energy consumption/smoothness) | `ip, waypoints, optimization_type` |
| `start_data_recording` | Data Recording | Start data recording session | `robot_id, record_types, duration` |
| `stop_data_recording` | Data Recording | Stop data recording session | `session_id` |
| `analyze_robot_data` | Data Analysis | Perform analysis on collected data | `robot_id, analysis_type, start_time, end_time` |
| `generate_robot_report` | Data Analysis | Generate robot operation report (PDF/JSON, etc.) | `robot_id, start_time, end_time, report_path` |
| `compare_robots_performance` | Data Analysis | Compare performance of multiple robots | `robot_ids, metric_columns, start_time, end_time` |
Note: Most tools require a robot connection to be established before they can be used; some tools depend on extended modules (trajectory planning/data recording/analysis/multi-machine coordination), which need to be initialized successfully first.
## 3. Disclaimer
Before using nUR MCP Server, please ensure that the operator has received UR robot safety training and is familiar with safety operations such as emergency stop (E-stop).
It is recommended to regularly check the operating status of the robot and MCP Server to ensure system stability and safety.
When using nUR MCP Server, the following safety regulations must be strictly observed:
The robot must operate within visual range
Operators should always ensure that the Universal Robots robot is in a visible position in order to monitor its operating status in real time.
It is forbidden to leave the operating area while the robot is running to avoid accidents that cannot be intervened in time.
Ensure a safe working environment
Before the robot runs, it is necessary to check and clear surrounding obstacles to ensure that no personnel, equipment or other objects enter the dangerous area.
Set up physical guardrails or safety light curtains when necessary to prevent unauthorized personnel from entering the work area.
Exemption from liability for violations of safety regulations
If personal injury, equipment damage or production accidents are caused by failure to comply with the above safety requirements (such as being out of monitoring, failure to clean up the work area, etc.), we will not assume any legal liability or compensation obligations.
All operational risks and consequences shall be borne by the user.
## 4. Version Release
### 4.1 Recent Updates
* 2025.05.15 : nUR_MCP_SERVER first release
### 4.2 Future Plans
* Support the exclusive MCP Client of nUR MCP Server to enhance the safety functions of the actuator.
* Add UR robot log recording
* Back up and upload UR robot programs
## 5. Quick Start
### 5.1 Based on the product (for ordinary users)
#### 5.1.1 Engine & Dependencies
* **Recommended System Version:**
```text
macOS Users: macOS Monterey 12.6 or later
Linux Users: CentOS 7 / Ubuntu 20.04 or later
Windows Users: Windows 10 LTSC 2021 or later
```
* **Software Requirements:**
MCP Server Environment
```text
Python 3.11 or later
pip 25.1 or later
UV Package Manager 0.6.14 or later
bun 1.2.8 or later
```
MCP Client
```text
Claude Desktop 3.7.0 or later
Cherry Studio 1.2.10 or later
Cline 3.14.1 or later
ClaudeMind, Cursor, NextChat, ChatMCP, Copilot-MCP, Continue, Dolphin-MCP, Goose have not been tested.
```
LLM Large Language Model
```text
DeepSeek-V3-0324 or later
DeepSeek-R1-671b or later
Qwen3-235b-a22b or later
Generally, large language models that support MCP are available, and models other than the list have not been tested.
Models deployed by Ollama cannot call Tool for the time being, and it is being resolved...
```
#### 5.1.2 Installation
**MCP Server Installation:**
1. Install Python 3.11 or later.
2. Install pip 25.1 or later.
3. Install UV Package Manager 0.6.14 or later.
4. Install bun 1.2.8 or later.
5. Install MCP Server:
```
git clone https://gitee.com/nonead/Nonead-Universal-Robots-MCP.git
cd Nonead-Universal-Robots-MCP
pip install -r requirements.txt
```
**MCP Client Configuration:**
**To use with Claude Desktop, add the server configuration:**
MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"nUR_MCP_SERVER": {
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
]
}
}
}
Windows: %APPDATA%/Claude/claude_desktop_config.json
{
"mcpServers": {
"nUR_MCP_SERVER": {
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
]
}
}
}
**To use with Cherry Studio, add the server configuration:**
MacOS & Linux:
```
{
"mcpServers": {
"Nonead-Universal-Robots-MCP": {
"name": "Nonead-Universal-Robots-MCP",
"type": "stdio",
"description": "Nonead-Universal-Robots-MCP is an intelligent industrial collaborative robot control middleware system built based on the MCP (Model Control Protocol) interface protocol. It realizes the natural language interactive control of industrial robots by integrating large language models (LLM). This product adopts a Client-Server architecture design and supports deep integration with the entire series of Universal Robots collaborative robots, revolutionizing the traditional industrial robot programming of teach pendants.",
"isActive": true,
"registryUrl": "https://pypi.tuna.tsinghua.edu.cn/simple",
"timeout": "600",
"provider": "拓德科技",
"providerUrl": "https://www.nonead.com",
"logoUrl": "https://www.nonead.com/assets/img/vi/5.png",
"tags": [
"优傲机器人大语言模型控制系统"
],
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
],
"installSource": "unknown"
}
}
}
```
Windows:
```
{
"mcpServers": {
"n5JzpK_3v_bgPnNNxry2o": {
"name": "NONEAD Universal-Robots MCP Server",
"type": "stdio",
"description": "Nonead-Universal-Robots-MCP is an intelligent industrial collaborative robot control middleware system built based on the MCP (Model Control Protocol) interface protocol. It realizes the natural language interactive control of industrial robots by integrating large language models (LLM). This product adopts a Client-Server architecture design and supports deep integration with the entire series of Universal Robots collaborative robots, revolutionizing the traditional industrial robot programming of teach pendants.",
"isActive": true,
"registryUrl": "https://pypi.tuna.tsinghua.edu.cn/simple",
"provider": "拓德科技",
"providerUrl": "https://www.nonead.com",
"logoUrl": "https://www.nonead.com/assets/img/vi/5.png",
"tags": [],
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
],
"installSource": "unknown"
}
}
}
```
**To use with Cline, add the server configuration:**
MacOS & Linux:
{
"mcpServers": {
"nUR_MCP_SERVER": {
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
]
}
}
}
Windows:
{
"mcpServers": {
"nUR_MCP_SERVER": {
"command": "uvx",
"args": [
"https://www.nonead.com/download/nonead_universal_robots_mcp-0.1.4-py3-none-any.whl",
"nonead-universal-robots-mcp"
]
}
}
}
### 5.2 Based on Toolkit (For Developers)
#### 5.2.1 Engine & Dependencies
* **Recommended System Version:**
```text
macOS Users: macOS Monterey 12.6 or later
Linux Users: CentOS 7 / Ubuntu 20.04 or later
Windows Users: Windows 10 LTSC 2021 or later
```
* **Software Requirements:**
MCP Server Environment
```text
Python 3.11 or later
pip 25.1 or later
UV Package Manager 0.6.14 or later
bun 1.2.8 or later
```
LLM Large Language Model
```text
DeepSeek-V3-0324 or later
DeepSeek-R1-671b or later
Qwen3-235b-a22b or later
Generally, any large language model that supports MCP is available. Models outside the list have not been tested.
Models deployed with Ollama cannot currently call Tool and are being resolved...
```
#### 5.2.2 Installation
**macOS / Linux /Windows Developers**
```text
Python 3.11 or later
pip 25.1 or later
UV Package Manager 0.6.14 or later
bun 1.2.8 or later
```
#### 5.2.3 Usage
Here are some examples of tasks you can have the large language model perform:
* Connect to Universal Robots IP: 192.168.1.199
* Get the current pose coordinates of the Universal Robots TCP end effector
* List all instructions for the nUR_MCP_SERVER tool
* Get all hardware data of the Universal Robots
* Execute a Universal Robots script program
* Run the Universal Robots built-in program XXXX.urp
* Now set the Universal Robots with IP 172.22.109.141 to be called Robot A, and the Universal Robots with IP 172.22.98.41 to be called Robot B. Connect these two robots, record the current TCP pose of Robot A and Robot B, as well as the key positions. Robot A is on the left, and Robot B is on the right. Analyze the relationship between the poses of the two robots.
* Execute the following instructions step by step, Universal Robots IP: 192.168.1.199, record the current TCP pose, then execute: TCP moves 20mm in the +Z direction, then moves 50mm in the -Y direction, then moves 30mm in the +X direction, repeat 5 times.
* Write a Universal Robots script program and execute it. The program requires: using the current pose as the center and the base plane as the feature, draw a circle with a radius of 50mm.
* Now set the Universal Robots with IP 172.22.109.141 to be called Robot A, and the Universal Robots with IP 172.22.98.41 to be called Robot B. Connect these two robots. The following instructions will only control the actions of Robot A. Please synchronize the mirror movement of Robot B.
## 6. Technical Architecture
MCP adopts a client-server architecture, enabling communication between models and external resources through standardized protocols.
Client-Server Model
The MCP architecture includes the following core components:
MCP Host: The LLM application (such as Claude Desktop or IDE) that initiates the connection, wishing to access data through MCP.
MCP Client: A protocol client maintained within the host application with a 1:1 connection to the server.
MCP Server: A lightweight program that exposes specific functions through the standardized Model Context Protocol.
Local Data Source: Computer files, databases, and services that the MCP server can securely access.
Remote Services: External systems available over the Internet that the MCP server can connect to (e.g., via API).
Core Components
In the MCP architecture, each component has the following responsibilities:
MCP Host:
Provides a user interface
Manages connections to LLM providers
Integrates the MCP client to access external resources
MCP Client:
Establishes and maintains connections with the MCP server
Sends requests and receives responses
Handles data exchange according to the MCP protocol standard
MCP Server:
Processes requests from the client
Performs specific functions or provides resource access
Formats responses according to the MCP protocol standard
Communication Protocol
MCP uses JSON-RPC 2.0 as the basic communication protocol, supporting the following types of messages:
Requests: Messages from the client to the server or from the server to the client to initiate an operation.
Responses: Replies to requests, containing the result of the request or error information.
Notifications: Unidirectional messages that do not require a response, typically used for event notifications.
MCP supports multiple transport mechanisms, including:
Standard Input/Output (Stdio): Suitable for local servers, implemented through inter-process communication.
Server-Sent Events (SSE): An HTTP-based transport mechanism suitable for remote servers.
Advantages of MCP
MCP has significant advantages over traditional integration methods, mainly in terms of uniformity, security, and scalability.
Uniformity
MCP solves the fragmentation problem of traditional integration methods by standardizing the way AI systems interact with external data sources:
Plug-in Access: Implements plug-in access to various data sources through a unified protocol, avoiding writing separate code for each data source.
Cross-Platform Compatibility: Supports different AI models and platforms, improving system interoperability.
Simplified Development: Reduces development complexity, allowing developers to focus on business logic rather than underlying integration.
Security
MCP has built-in security mechanisms to ensure data security during transmission and processing:
Sensitive Information Protection: Ensures that sensitive information (such as API keys, user data) is fully protected during data interaction.
Access Control: MCP servers can implement fine-grained access control to ensure that only verified requests can access specific resources.
Local Processing: Avoids uploading sensitive information to third-party platforms by processing data locally.
Scalability
MCP's modular design makes the system highly scalable:
Multi-Service Connection: Supports multiple services connecting to any compatible client, providing a standardized, universal protocol for sharing resources, tools, and prompts.
Ecosystem Expansion: As the ecosystem matures, developers can leverage an increasing number of pre-built components.
Customization: Developers can create custom MCP servers as needed to extend system functionality.
## 7. Contact Us
**GitHub**: <https://github.com/nonead/Nonead-Universal-Robots-MCP>
**gitee**: <https://gitee.com/nonead/Nonead-Universal-Robots-MCP>
**Official Website**: <https://www.nonead.com>
<img src="./images/QR.gif" alt="Contact: Nonead Tech WeChat" width="200">
## 8. Differences between nUR MCP Server and Other MCP Servers
Users of nUR MCP Server must have a very high level of security awareness and need to undergo Universal Robots usage training, because the large language model operates real robots, and improper operation can lead to personal injury and property damage. Remember this.
## 9. Citation
If you use this software, please cite it in the following way:
* [nURMCP: NONEAD Uninversal-Robots Model Context Protocol Server](https://www.nonead.com)
* 拓德诠释智造之韵，创新引领世界之变
Nonead demonstrates the true meaning of intelligent manufacturing, pioneering innovations that reshape our world.
## 10. License Agreement
This project adopts a User-Segmented Dual Licensing model.
**Core Principles**
* Individual users and companies/organizations with 10 or fewer people: GNU Affero General Public License v3.0 (AGPLv3) applies by default.
* Companies/organizations with more than 10 people: Must obtain a Commercial License.
Definition: "10 people or less"
Refers to the total number of individuals in your organization (including companies, non-profit organizations, government agencies, educational institutions, or any other entity) who can access, use, or in any way directly or indirectly benefit from the functions of this software (nUR_MCP_SERVER) does not exceed 10 people. This includes but is not limited to developers, testers, operations personnel, end users, and indirect users through integrated systems.
### 10.1 Open Source License: AGPLv3 - Applicable to individuals and organizations with 10 people or less
* If you are an individual user, or your organization meets the definition of "10 people or less" above, you are free to use, modify, and distribute nUR_MCP_SERVER under the terms of AGPLv3. The full text of AGPLv3 can be accessed at https://www.gnu.org/licenses/agpl-3.0.html.
* **Core Obligation:** A key requirement of AGPLv3 is that if you modify nUR_MCP_Server and provide services over the network, or distribute the modified version, you must provide the corresponding complete source code to the recipient under the AGPLv3 license. Even if you meet the "10 people or less" standard, if you want to avoid this source code disclosure obligation, you also need to consider obtaining a commercial license (see below).
* Be sure to read and understand all the terms of AGPLv3 carefully before use.
### 10.2 Commercial License - Applicable to organizations with more than 10 people, or users who wish to circumvent AGPLv3 obligations
* **Mandatory Requirement:** If your organization **does not** meet the definition of "10 people or less" above (that is, 11 or more people can access, use, or benefit from this software), you **must** contact us to obtain and sign a commercial license before using nUR_MCP_SERVER.
* **Voluntary Choice:** Even if your organization meets the "10 people or less" condition, but if your use case **cannot meet the requirements of AGPLv3** (especially the obligation regarding source code disclosure), or you need specific commercial terms **not provided** by AGPLv3 (such as guarantees, compensation, no Copyleft restrictions, etc.), you **must** also contact us to obtain and sign a commercial license.
* **Common situations requiring a commercial license include (but are not limited to):**
* Your organization has more than 10 people.
* (Regardless of organization size) You want to distribute a modified version of nUR_MCP_SERVER, but do not want to disclose the source code of your modified parts according to AGPLv3.
* (Regardless of organization size) You want to provide network services (SaaS) based on the modified nUR_MCP_SERVER, but do not want to provide the modified source code to service users according to AGPLv3.
* (Regardless of organization size) Your company policy, customer contract, or project requirements do not allow the use of software licensed under AGPLv3, or require closed-source distribution and confidentiality.
* **Obtaining a Commercial License:** Please contact the nUR_MCP_SERVER development team via email service@nonead.com to discuss commercial authorization matters.
### 10.3 Contributions
* We welcome community contributions to nUR_MCP_SERVER. All contributions submitted to this project will be considered provided under the AGPLv3 license.
* By submitting contributions to this project (for example, through Pull Request), you agree that your code is licensed to this project and all subsequent users under the AGPLv3 license (regardless of whether these users ultimately follow AGPLv3 or a commercial license).
* You also understand and agree that your contributions may be included in versions of nUR_MCP_SERVER distributed under a commercial license.
### 10.4 Other Terms
* The specific terms and conditions of the commercial license are subject to the formal commercial license agreement signed by both parties.
* The project maintainers reserve the right to update this licensing policy (including user size definitions and thresholds) as needed. Relevant updates will be notified through official project channels (such as code repositories, official websites).
## 11. Development Core Team
Suzhou Nonead Robotics Technology Co., Ltd. MCP Server Development Team
**Tony Ke** <tonyke@nonead.com>
**Micro Zhu** <microzhu@nonead.com>
**Anthony Zhuang** <anthonyzhuang@nonead.com>
**Quentin Wang** <quentinwang@nonead.com>
