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">Simplified Chinese</a> |
<a href="./README.jp.md">Japanese</a> |
<a href="./README.ko.md">Korean</a> |
<a href="./README.de.md">German</a> |
<a href="./README.fr.md">French</a> |
<a href="./README.ru.md">Russian</a> |
<a href="./README.th.md">Thai</a> |
<a href="./README.es.md">Spanish</a> |
<a href="./README.ar.md">Arabic</a> |
<a href="./README.da.md">Danish</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.com'>
<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 Control Protocol) is a communication protocol developed by Anthropic (open-sourced in November 2024), primarily used to enable large AI models (such as DeepSeek-V3-0324, DeepSeek-R1, Qwen3, etc.) to access external data, tools, and services more efficiently, providing more accurate and intelligent responses.
What can MCP do?
Provide context information:
Applications can pass additional information such as files and database content to AI, helping it better understand the problem.
For example, let AI read a report and answer questions based on the report content.
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 a database to generate reports.
Build intelligent workflows:
Developers can combine multiple MCP services to let AI complete complex tasks, such as automated data analysis and intelligent customer service.
Ensure data security:
MCP runs locally, avoiding sensitive data being uploaded to the cloud and protecting privacy.
## 2. How MCP works?
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), supporting requests, responses, and real-time notifications.
## 3. Main functions of MCP Server
The MCP Server is equivalent to an "assistant" for AI, providing the following support:
Access data (Resource Exposure)
Provide files, databases, memory data, etc., such as:
file:///docs/report.pdf (read local file), db://sales/records (query database), execute operations (Tool Provisioning)
Provide callable functions, such as:
search_database(sql_query) (execute SQL query), save_file(path, content) (save file), real-time updates (Dynamic Notification),
When data changes, the server can actively notify AI to ensure the latest information, session management (Session Management),
Manage AI connections with the server to ensure stable communication.
## 2. Core Functions of nUR MCP Server
The nUR_MCP_SERVER product, developed by Nonead, is a smart robot control middleware system built based on the MCP (Model Control Protocol) interface protocol, integrating large language models (LLM) to achieve natural language interactive control of industrial robots.
Product Overview:
nUR_MCP_SERVER is a client-server architecture design that supports deep integration with Universal Robots' full series of collaborative robots, revolutionizing the traditional teaching pendant programming industrial robot operation paradigm.
Core Technology Architecture:
1. Semantic Parsing Engine
Equipped with a multi-layer Transformer architecture NLP processing module, supporting contextual command parsing, achieving end-to-end conversion from natural language to robot control instructions, with an instruction recognition accuracy of 98.6%.
2. Dynamic Script Generation System
A code generation framework based on LLM, which can automatically convert natural language instructions into URScript robot control scripts, supporting real-time syntax verification and security verification, with a generation efficiency 12 times higher than traditional programming.
3. Multimodal Control Interface
- MCP Protocol Extension Layer: supports TCP/UDP dual-mode communication, providing µs-level instruction response.
- Device Abstraction Layer: achieves standardized access for URCap plugins.
- Data Bus: based on TCP/IP Ethernet protocol, achieving multi-machine collaborative control.
Core Functional Characteristics:
▶ Natural Language Instant Control
Directly drive robot movement through voice/text instructions (pose control, trajectory planning, IO operation), supporting dynamic parameter injection and real-time motion correction.
▶ Intelligent Data Collection System
- Collect 12-dimensional state data such as joint torque and end pose in real-time.
- Support natural language-defined data filtering rules.
- Automatically generate structured data reports (CSV/JSON/XLSX).
▶ Multi-Machine Collaborative Control
Based on a distributed task scheduling algorithm, with the MCP-Client developed by Nonead, it can manage ≤12 UR robot clusters simultaneously, supporting voice cascaded instructions and cross-device task scheduling.
▶ Adaptive Learning Module
Built-in incremental training framework, continuously optimizing instruction-action mapping relationships through user feedback, with a system iterative learning cycle ≤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 functional classification table of nUR_MCP_SERVER tools (automatically generated from the source code):**
| Tool Name | Functional Classification | Brief Description | Main Parameters |
|--------|----------|----------|----------|
| `connect_ur` | Connection Management | Establish a connection with a specified IP UR robot | `ip` |
| `disconnect_ur` | Connection Management | Disconnect from a specified robot | `ip` |
| `get_serial_number` | Device Information | Get robot serial number | `ip` |
| `get_time` | Status Monitoring | Get robot uptime (seconds) | `ip` |
| `get_ur_software_version` | Device Information | Get Polyscope software version | `ip` |
| `get_robot_model` | Device Information | Get robot model | `ip` |
| `get_safety_mode` | Device Information | Get safety mode | `ip` |
| `get_robot_mode` | Status Monitoring | Get robot operating mode | `ip` |
| `get_program_state` | Program Control/Status | Get current loaded program and execution status | `ip` |
| `get_actual_tcp_pose` | Motion Control | Get current TCP pose | `ip` |
| `get_actual_joint_pose` | Motion Control | Get 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 robot voltage (V) | `ip` |
| `get_actual_robot_current` | Status Monitoring | Get robot current (A) | `ip` |
| `get_actual_joint_voltage` | Status Monitoring | Get joint voltage (V) | `ip` |
| `get_actual_joint_current` | Status Monitoring | Get joint current (A) | `ip` |
| `get_joint_temperatures` | Status Monitoring | Get joint temperature (°C) | `ip` |
| `get_programs` | Program Control | List .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 X-axis (relative) | `ip, distance` |
| `movel_y` | Motion Control | Move along Y-axis (relative) | `ip, distance` |
| `movel_z` | Motion Control | Move along Z-axis (relative) | `ip, distance` |
| `draw_circle` | Motion Control | Draw a circle on a specified plane | `ip, center, r, coordinate` |
| `draw_square` | Motion Control | Draw a square on a specified plane | `ip, origin, border, coordinate` |
| `draw_rectangle` | Motion Control | Draw a rectangle on a specified plane | `ip, origin, width, height, coordinate` |
| `setup_multi_robot_coordination` | Multi-Machine Collaboration | Register robots and set collaboration mode | `robot_ids, collaboration_mode` |
| `create_collaborative_task` | Multi-Machine Collaboration | Create a collaborative task | `task_name, robot_assignments, dependencies` |
| `execute_collaborative_task` | Multi-Machine Collaboration | Execute a collaborative task | `task_id` |
| `generate_bezier_path` | Trajectory Planning | Generate a Bezier curve path based on control points | `control_points, num_points` |
| `optimize_trajectory` | Trajectory Planning | Optimize a given path (time/energy/smooth) | `ip, waypoints, optimization_type` |
| `start_data_recording` | Data Recording | Start a data recording session | `robot_id, record_types, duration` |
| `stop_data_recording` | Data Recording | Stop a data recording session | `session_id` |
| `analyze_robot_data` | Data Analysis | Execute analysis on collected data | `robot_id, analysis_type, start_time, end_time` |
| `generate_robot_report` | Data Analysis | Generate a robot operation report (PDF/JSON, etc.) | `robot_id, start_time, end_time, report_path` |
| `compare_robots_performance` | Data Analysis | Compare multi-robot performance | `robot_ids, metric_columns, start_time, end_time` |
Note: Most tools require establishing a robot connection before use; some tools depend on extension modules (trajectory planning/data recording/analysis/multi-machine coordination), which need to be initialized successfully.
## 3. Disclaimer
Please ensure that operators have received UR robot safety training and are familiar with emergency stop (E-stop) and other safety operations before using nUR MCP Server.
It is recommended to regularly check the operation status of the robot and MCP Server to ensure system stability and safety.
When using nUR MCP Server, you must strictly comply with the following safety specifications:
Robots must operate within a visible range.
Operators should always ensure that Universal Robots are within line of sight to monitor their operation in real-time.
Prohibited from leaving the operation area while the robot is running to prevent accidents.
Ensure a safe working environment.
Before robot operation, obstacles must be checked and cleared to ensure no personnel, equipment, or objects enter the hazardous area.
If necessary, set up physical protection barriers or safety light curtains to prevent unauthorized personnel from entering the work area.
Waiver of liability for violating safety specifications
If the above safety requirements are not followed (e.g., leaving the monitoring area, not clearing the work area, etc.), resulting in personal injury, equipment damage, or production accidents, we will not bear any legal responsibility or compensation obligations.
All operation risks and consequences shall be borne by the user.
## 4. Version Release
### 4.1 Recent Updates
* 2025.05.15: nUR_MCP_SERVER released
### 4.2 Future Plans
* Support for nUR MCP Server's exclusive MCP Client, enhancing executor security features.
* Add Universal Robots log recording
* Backup and upload Universal Robots programs
## 5. Quick Start
### 5.1 Based on Product (for ordinary users)
#### 5.1.1 Engine & Dependencies
* **Recommended system versions:**
```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 not tested.
```
LLM Large Language Model
```text
DeepSeek-V3-0324 or later
DeepSeek-R1-671b or later
Qwen3-235b-a22b or later
Generally, MCP-supported large language models are available; models not listed are not tested
Ollama-deployed models currently cannot call Tool, 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 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 server configuration:**
MacOS & Linux:
```
{
"mcpServers": {
"Nonead-Universal-Robots-MCP": {
"name": "Nonead-Universal-Robots-MCP",
"type": "stdio",
"description": "Nonead-Universal-Robots-MCP is a smart industrial collaborative robot control middleware system built based on MCP (Model Control Protocol) interface protocol, which realizes natural language interactive control of industrial robots by integrating large language models (LLM). The product adopts Client-Server architecture design, supports deep integration with Universal Robots' full series of collaborative robots, and innovates traditional teaching device programming industrial robots.",
"isActive": true,
"registryUrl": "https://pypi.tuna.tsinghua.edu.cn/simple",
"timeout": "600",
"provider": "Nonead",
"providerUrl": "https://www.nonead.com",
"logoUrl": "https://www.nonead.com/assets/img/vi/5.png",
"tags": [
"Universal Robots large language model control system"
],
"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 a smart industrial collaborative robot control middleware system built based on MCP (Model Control Protocol) interface protocol, which realizes natural language interactive control of industrial robots by integrating large language models (LLM). The product adopts Client-Server architecture design, supports deep integration with Universal Robots' full series of collaborative robots, and innovates traditional teaching device programming industrial robots.",
"isActive": true,
"registryUrl": "https://pypi.tuna.tsinghua.edu.cn/simple",
"provider": "Nonead",
"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 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 Versions:**
```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, MCP large language models are supported, and models not in the list have not been tested
Ollama deployed models cannot call Tool temporarily, 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 let the large language model execute:
* Connect to Universal Robots IP: 192.168.1.199
* Get the current pose coordinates of the Universal Robots TCP end effector
* List all instructions of the nUR_MCP_SERVER tool
* Get all hardware data of the Universal Robots
* Execute the script program of the Universal Robots
* Run the Universal Robots built-in program XXXX.urp
* Now set the IP 172.22.109.141 Universal Robots named A robot, IP 172.22.98.41 Universal Robots named B robot, connect the two robots, record the TCP pose and key positions of A and B robots, A robot on the left, B robot on the right, analyze the relationship between the two robots' poses.
* Step by step execute the following instructions, Universal Robots IP: 192.168.1.199, record the current TCP pose, then execute: TCP move +Z 20mm, then move -Y 50mm, then move +X 30mm, cycle 5 times.
* Write the Universal Robots script program and execute it, the program requires: take the current pose as the center, the base plane as the feature, draw a circle with a radius of 50mm.
* Now set the IP 172.22.109.141 Universal Robots named A robot, IP 172.22.98.41 Universal Robots named B robot, link two robots, the following instructions will only control A robot action, please synchronize B robot mirror motion.
## 6. Technical Architecture
MCP adopts a client-server architecture, which realizes communication between the model and external resources through a standardized protocol.
Client-Server Model
The MCP architecture contains the following core components:
MCP Host: The LLM application (such as Claude Desktop or IDE) that initiates the connection, which hopes to access data through MCP.
MCP Client: The protocol client that maintains a 1:1 connection with the server within the host application.
MCP Server: A lightweight program that exposes specific functions through the standardized Model Context Protocol.
Local Data Source: The computer files, databases, and services that the MCP server can access securely.
Remote Service: The external systems (e.g., through APIs) that the MCP server can connect to.
## 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 high safety awareness and need to undergo Universal Robots use training, as large language models operate real robots, and improper operation may lead to personal injury and property loss.
## 9. References
If you use this software, please cite it as follows:
* [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**
* Personal users and enterprises/organizations with 10 or fewer people: Default application of GNU Affero General Public License v3.0 (AGPLv3).
* Enterprises/organizations with more than 10 people: Must obtain a Commercial License.
Definition: "10 or fewer people"
Refers to the total number of individuals in your organization (including companies, non-profit organizations, government agencies, educational institutions, etc.) who can access, use, or benefit directly or indirectly from the functions of this software (nUR_MCP_SERVER). This includes but is not limited to developers, testers, operation personnel, end-users, and indirect users through integrated systems.
### 10.1 Open Source License (AGPLv3) - Applicable to Personal and 10 or Fewer Organizations
* If you are a personal user or your organization meets the above definition of "10 or fewer people," you can 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 Obligations:** One of the key requirements of AGPLv3 is that if you modify nUR_MCP_Server and provide services through the network, or distribute modified versions, you must provide the complete source code to the recipient under the AGPLv3 license. Even if you meet the "10 or fewer people" standard, if you wish to avoid this source code disclosure obligation, you also need to consider obtaining a commercial license (see below).
* Please read and understand all terms of AGPLv3 carefully before use.
### 10.2 Commercial License - Applicable to Organizations with More than 10 People or Users Who Want to Avoid AGPLv3 Obligations
* **Mandatory Requirements:** If your organization **does not** meet the above definition of "10 or fewer people" (i.e., 11 or more people can access, use, or benefit from this software), you **must** contact us to obtain and sign a commercial license to use nUR_MCP_SERVER.
* **Voluntary Choice:** Even if your organization meets the "10 or fewer people" condition, but your usage scenario **cannot meet the requirements of AGPLv3** (especially regarding the obligation of source code disclosure), or you need specific commercial terms not provided by AGPLv3 (such as guarantees, compensation, no Copyleft restrictions, etc.), you **must** contact us to obtain and sign a commercial license.
* **Common Situations Requiring Commercial License Include (but not limited to):**
* Your organization has more than 10 people.
* (Regardless of organization size) You want to distribute modified versions of nUR_MCP_SERVER but do not want to disclose the source code of your modifications under AGPLv3.
* (Regardless of organization size) You want to provide network services (SaaS) based on modified nUR_MCP_SERVER but do not want to provide the modified source code to service users under AGPLv3.
* (Regardless of organization size) Your company's policy, customer contract, or project requirements do not allow the use of AGPLv3 licensed software or require closed-source distribution and confidentiality.
* **Obtain Commercial License:** Please contact the nUR_MCP_SERVER development team at service@nonead.com to discuss commercial authorization.
### 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 (e.g., through Pull Request), you agree that your code is authorized under the AGPLv3 license to this project and all subsequent users (regardless of whether they ultimately follow AGPLv3 or commercial licensing).
* You also understand and agree that your contributions may be included in versions of nUR_MCP_SERVER distributed under commercial licenses.
### 10.4 Other Terms
* The specific terms and conditions of the commercial license shall be based on 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 repository, official website).
## 11. Development Core Team
Suzhou Nonead Robot 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>
