# Shunwang Tech MCP > Shunwang Tech handles edge computing and PC Bang infrastructure management. It lets your AI agent monitor distributed GPU clusters, schedule tasks across nodes, and manage resources without you touching a dashboard. Your client can list all compute nodes, check real-time CPU/GPU metrics, audit resource usage summaries, deploy new inference jobs using `create_task`, or even send remote shutdown commands via `send_node_command`. It's built for infrastructure engineers running massive, distributed networks. ## Overview - **Category:** cloud-infrastructure - **Price:** Free - **Tags:** edge-computing, gpu-resource-management, cluster-monitoring, task-scheduling, distributed-systems ## Description Listen up. This server gives your agent total command over massive edge computing setups—the kind of stuff running in PC Bangs or distributed GPU clusters. You're managing infrastructure, not just sending emails. It lets your AI client monitor complex hardware networks and schedule tasks across nodes without you ever having to touch a dashboard interface. Your agent handles the grunt work, letting you focus on what matters. When you need to know exactly what compute resources are available, your agent can first run `list_clusters` to get a rundown of every computing cluster in your infrastructure. From there, it uses `list_nodes` to pull a comprehensive list of every connected node, so you'll always know the scope of the network. If y'all need to know what kind of OS or environment is ready for deployment, `list_images` shows exactly which system images are available for your tasks. For hardware specifics—like figuring out if a job needs 24GB VRAM or something else—you gotta use `get_gpu_specs`. This returns the detailed specs on all the GPUs connected to your network so you can match jobs to proper hardware. To see what's running and how much juice it’s using, your agent first checks in with `list_tasks` for a history of everything that’s happened across the whole cluster. For current health checks, `get_resource_usage` spits out a summary report detailing the CPU, GPU, and RAM utilization rates across all defined resources. If you need to dig into one specific machine, `get_node` lets you retrieve the detailed status of a single computing node, whether you know its ID or its name. That's how you keep tabs on things. When it comes time for action—and there’s always time for action—your agent can schedule compute tasks by calling `create_task`. This deploys a new job onto the cluster and kicks off execution immediately. If that task goes sideways or you just need to test something else, you'll use `stop_task` to terminate a running process using its unique ID. You control the entire lifecycle from deployment right through to termination. Beyond scheduling, your agent manages the physical state of the machines. To give a node a direct command—like initiating a reboot or forcing a shutdown—it uses `send_node_command`. This sends that specific management instruction straight to an identified compute node. And remember, if you need to know why something went down and want to check the status again later, running `get_node` gives you all the current details on that machine's operational state. Basically, your agent handles inventory checks—listing clusters and nodes; it monitors resources by getting utilization reports and node specs; and it manages the whole job lifecycle from deployment via `create_task` to termination with `stop_task`. It’s built for infrastructure engineers running massive, distributed networks. You use this so you don't gotta stare at dashboards all day long. ## Tools ### create_task Deploys a new computing task onto the cluster, starting its execution. ### get_gpu_specs Returns detailed hardware specifications for available GPUs in your network. ### get_node Retrieves the specific details and status of a single computing node by its ID or name. ### get_resource_usage Gets a summary report showing current CPU, GPU, and RAM utilization across defined resources. ### list_clusters Returns a list of all available computing clusters in your infrastructure. ### list_images Shows which operating system or environment images are currently available for task deployment. ### list_nodes Returns a comprehensive list of all computing nodes connected to your network. ### list_tasks Lists the current running and historical computing tasks across your entire cluster setup. ### send_node_command Sends a specific management command (like reboot or shutdown) directly to an identified compute node. ### stop_task Immediately terminates and stops a running computing task by its unique ID. ## Prompt Examples **Prompt:** ``` List all active computing nodes in my Shunwang network. ``` **Response:** ``` I've scanned your infrastructure and found 15 active nodes. Most are running at optimal capacity, but node SW-009 is showing high GPU load. Would you like to see its details? ``` **Prompt:** ``` Deploy a new task to cluster 'Huzhou-Edge-01' using image 'ai-inference-v2'. ``` **Response:** ``` Processing deployment... Your task has been successfully created and is being deployed to cluster 'Huzhou-Edge-01'. Task ID: TSK-8821. I'll monitor its initialization for you. ``` **Prompt:** ``` What is the current GPU resource usage across my entire Shunwang infrastructure? ``` **Response:** ``` Across your network, GPU utilization is currently at 68%. You have 120 RTX 4090 nodes available, with 45 currently dedicated to AI inference tasks. Would you like a breakdown by cluster? ``` ## Capabilities ### Audit Resource Usage Checks the current utilization levels and resource summaries across all your connected computing clusters. ### Manage Node Lifecycle Retrieves detailed information about specific compute nodes, allowing you to check status and send remote commands like reboot or shutdown. ### Schedule Compute Tasks Creates new computing tasks on the cluster using defined images and controls their entire lifecycle from deployment to termination. ### Inventory Infrastructure Lists all available compute nodes, clusters, and system images so your agent knows what resources it can target. ### Check Hardware Specifications Retrieves the technical specs of available GPUs, helping you match tasks to appropriate hardware. ## Use Cases ### Auditing Post-Crash Node Status A LAN house reports that one cluster is slow. Instead of tracing network cables, you ask your agent to run `list_nodes` and then `get_resource_usage`. The agent pinpoints the node (e.g., SW-012) showing high utilization or low RAM, allowing immediate troubleshooting. ### Scaling AI Inference Capacity You need to run a new model version. You ask your agent to first check available hardware using `get_gpu_specs`. Once validated, you instruct it to deploy the job using `create_task` onto cluster 'A', confirming capacity before risking deployment failure. ### Clearing Old Test Jobs After a test run, several computing tasks are still consuming resources. You ask your agent to execute `list_tasks`, get the IDs of the old jobs, and then issue multiple calls to `stop_task` across different clusters. ### Remote Network Maintenance You notice a critical node is behaving erratically. You tell your agent: 'Reboot Node X.' The agent executes `send_node_command`, forcing the necessary action without needing physical access or SSH credentials. ## Benefits - Real-time oversight of every node. Instead of logging into multiple dashboards, simply ask your agent to run `list_nodes` and get a full inventory of active computing resources. - Instant task control. Need to kill a runaway process? Use `stop_task`. You tell the agent which task ID needs terminating, and it handles the API call instantly. - Know exactly what hardware you're using. Before deploying anything, run `get_gpu_specs` to verify if the cluster has the necessary GPU type or memory capacity for your model inference. - Better resource planning. Don't guess about utilization. Run `get_resource_usage` to get a summary of CPU/GPU load across your entire network, helping you budget compute power. - Full lifecycle control. From listing clusters (`list_clusters`) to deploying a task with `create_task`, the agent manages the whole process—you just give the command. ## How It Works The bottom line is: Your AI client sends a natural language request, the server validates it against your credentials, and then uses one of its ten tools to execute the command on your hardware. 1. 1. Subscribe to this server on Vinkius Marketplace. 2. 2. Enter your specific Shunwang App Key and App Secret into your AI client's settings. 3. 3. Start requesting operations (e.g., 'What is the GPU usage?') through Claude, Cursor, or any MCP-compatible agent. ## Frequently Asked Questions **How do I check all my compute nodes using Shunwang Tech MCP Server?** Run the `list_nodes` tool. This returns a full inventory of every node connected to your network, giving you their IDs and basic status immediately. **Can I deploy tasks without checking resource usage first using Shunwang Tech MCP Server?** You can call `create_task` directly. However, we recommend running `get_resource_usage` beforehand. This prevents failed deployments because the system might be over-committed. **What tool do I use to reboot a specific node in Shunwang Tech MCP Server?** Use the `send_node_command` tool. You need to specify the target node and the command (e.g., 'reboot') for the action to execute. **How do I find out what images are available for new tasks?** Run `list_images`. This tool shows all the system environments or OS images you can select when calling `create_task`. **How do I authenticate my AI client before running `list_clusters`?** You use your provided Shunwang App Key and Secret to authorize the connection. This process confirms you have rights to manage the infrastructure, so any action starts with proper authentication. **What happens if I need to manually stop a running task using `stop_task`?** The agent sends a termination signal directly to the specific Task ID. If the process fails or won't shut down gracefully, you'll receive an error code detailing why. **Can I use `get_gpu_specs` to compare hardware across multiple nodes?** Yes. You run `get_gpu_specs` for each node ID individually. The output gives standardized data points—like VRAM and clock speed—that let you easily compare different pieces of hardware. **What does running `list_clusters` tell me about my network architecture?** It lists the logical groupings for your distributed resources. This helps you understand how your infrastructure is organized, allowing you to assign tasks based on physical or functional segments. **How do I check the real-time health of a specific computing node?** Use the `get_node` tool with the corresponding `node_id`. It will return real-time metrics including CPU, GPU, and Memory usage, as well as the current online status. **Can I deploy a new computing task using the agent?** Yes. Use the `create_task` tool. You will need to provide the `image_id` and the `cluster_id` where you want to deploy the task. You can also optionaly give the task a name. **Is it possible to remotely reboot a node through the chat?** Yes, using the `send_node_command` tool. You just need the `node_id` and specify 'reboot' as the command. This allows for rapid remote maintenance without manual intervention.