# Tencent START MCP > Tencent START MCP Server connects your AI agent directly to cloud gaming operations. It lets you manage game server sessions, check worker availability, and adjust user capacity limits for Tencent START Cloud Gaming. Use it to orchestrate complex scaling tasks without writing boilerplate API calls. ## Overview - **Category:** industry-titans - **Price:** Free - **Tags:** tencent-cloud, cloud-gaming, gaming-paas, session-orchestration, resource-management ## Description **Tencent START MCP Server** gives your AI agent direct command over cloud gaming operations for Tencent START Cloud Gaming. You'll manage entire game server sessions and orchestrate resource scaling without writing a single line of boilerplate API code. It handles everything from initial user connection to shutting down resources when the action is done. ### **Managing Game Sessions** You can initiate a new gaming session for any user using `create_session`. When a player is done, call `stop_game` to end the active instance and release its worker resource back into the pool. If you only need to cut the video feed without killing the whole game process, use `stop_publish_stream` or `stop_publish_stream_by_action` to stop the stream by specific action code. ### **Monitoring Infrastructure Status** To understand what's running, start with `list_games`, which gives you a rundown of every game title currently available on the Tencent GS platform. You can then check usage metrics: call `get_concurrent_user_info` to retrieve the current number of active users connected to a specific game ID. To see how close you are to hitting your limits, use `get_capacity_limit`, which checks the maximum allowed concurrent users for that same game ID. For deeper status checks, `list_workers` gives you a full inventory and operational status of every cloud gaming worker instance out there. If you need details on one specific user's machine, `get_worker_info` fetches detailed status information using the associated user ID. ### **Scaling and Resource Control** When player demand spikes, you don't want your service to crash. You can adjust the maximum number of simultaneous users for any game title by calling `modify_capacity_limit`, which updates that hard cap when scaling is necessary. Before a user connects, it’s smart to reserve their spot; use `try_lock_worker` to attempt reserving a worker instance for a specific user, keeping it locked down so no other process allocates it elsewhere. If you need to know what games are even available before running any checks, start with `list_games`. ### **Operational Flow** You can execute complex operational sequences through this single server connection. You'll first use `list_games` to identify the target title, then check current usage via `get_concurrent_user_info`, and verify the hard limit with `get_capacity_limit`. If you determine scaling is required, call `modify_capacity_limit`. Once capacity is set and workers are available (which you monitor using `list_workers`), you can execute a session start with `create_session` or pre-reserve resources by calling `try_lock_worker` for mission-critical users. When the user connects, their dedicated worker status comes through via `get_worker_info`. To ensure clean shutdown, you'll use `stop_game`, and if needed, follow up with a stream stop using either `stop_publish_stream` or `stop_publish_stream_by_action` to guarantee the video feed terminates cleanly. You won't need to write custom logic for these transitions; this server handles it all. ## Tools ### create_session Starts a new cloud gaming instance for a user. ### get_capacity_limit Checks the maximum allowed concurrent users for any given game ID. ### get_concurrent_user_info Retrieves the current number of active, connected users for a specific game. ### get_worker_info Fetches detailed status information for a worker associated with a particular user ID. ### list_games Lists all available game titles running on the Tencent GS platform. ### list_workers Gathers a list of all operational cloud gaming worker instances and their status. ### modify_capacity_limit Updates the maximum concurrent user limit for a specific game title when scaling is needed. ### stop_game Ends an active game session and releases the underlying worker resource back to the pool. ### stop_publish_stream_by_action Stops the video stream using an explicit action code to ensure clean termination. ### stop_publish_stream Stops the video stream feed for a specified user. ### try_lock_worker Attempts to reserve a worker instance for a user, preventing it from being allocated elsewhere. ## Prompt Examples **Prompt:** ``` List all cloud games available in region 'ap-guangzhou'. ``` **Response:** ``` I've fetched the game catalog for 'ap-guangzhou'. You have 3 active titles: 'League of Legends' (ID: game_101), 'CrossFire' (ID: game_202), and 'Naraka' (ID: game_303). Would you like to check the worker status for any of these? ``` **Prompt:** ``` Check the status of workers for game 'game_101'. ``` **Response:** ``` Querying worker status for 'League of Legends'... I found 50 total workers: 35 are 'Occupied', 12 are 'Idle' (Ready), and 3 are in 'Maintenance'. ``` **Prompt:** ``` Modify the concurrency limit for game 'game_202' to 100 users. ``` **Response:** ``` Connecting to capacity management... Concurrency limit for 'CrossFire' (ID: game_202) has been successfully updated to 100. The infrastructure is scaling to match. ``` ## Capabilities ### Start and Stop Game Sessions Initialize a cloud gaming session using `create_session` or release an instance completely with `stop_game`. ### Monitor Worker Status Get detailed worker information for specific users (`get_worker_info`) and list the status of all available workers (`list_workers`). ### Check Concurrency Limits Verify current user capacity using `get_capacity_limit` or check active concurrent usage with `get_concurrent_user_info`. ### Scale Capacity On Demand Adjust the maximum number of simultaneous users for a game ID by calling `modify_capacity_limit`. ### Lock Resources Reserve a cloud gaming instance for a user before they need it, preventing race conditions using `try_lock_worker`. ## Use Cases ### Handling a Peak Load Event A major game launch causes traffic to spike past the default capacity. Instead of waiting for manual alerts, the agent runs `get_concurrent_user_info` and sees the limit is breached. It immediately calls `modify_capacity_limit` to raise the ceiling, stabilizing service before users complain. ### User Login Flow Orchestration A user hits 'Play'. The agent first runs `try_lock_worker` for that specific user ID. If successful, it calls `create_session`. This sequence ensures the worker is reserved before resources are consumed. ### Debugging a Disconnected Client A client suddenly drops connection but isn't showing up in usage metrics. The agent checks `get_worker_info` for that user ID, confirming the last known status and whether the worker was properly released using `stop_game`. ### Pre-Launch Readiness Check The ops team needs to know if the platform is ready. They run `list_games` to confirm all titles are listed, then use `get_worker_info` and `list_workers` to verify that a sufficient number of workers are in 'Idle' status. ## Benefits - Stop manually checking capacity. Use `get_capacity_limit` to instantly see if you're hitting user limits, preventing unexpected service outages before they happen. - Manage player flow with precision. You can lock a resource using `try_lock_worker`, ensuring that when a user connects, the worker is ready and won't be assigned elsewhere. - Scale without downtime. When traffic spikes, run `modify_capacity_limit` to raise the concurrency ceiling immediately, accommodating sudden bursts of players. - Keep costs down by cleaning up. Use `stop_game` after a session ends; it reliably releases the worker instance back into the pool for reuse. - Gain full visibility. Running `list_workers` gives you an immediate inventory count and status (Occupied, Idle, Maintenance) across your entire fleet. ## How It Works The bottom line is: you provide the credentials once, and then your agent handles all the complex API calls needed to run game operations. 1. First, subscribe to the server and log in via your preferred AI client. Then, navigate to the Tencent Cloud Console to generate a SecretId and SecretKey for access management. 2. Next, you'll enable the Cloud Gaming (GS) service and input your credentials and desired region into the MCP fields. This authenticates your agent with the gaming platform. 3. Finally, your AI client uses the tools—like `list_games` or `get_worker_info`—to read the current state of the system and execute commands to manage sessions. ## Frequently Asked Questions **How do I check if a user can play right now using Tencent START MCP Server?** Run `get_concurrent_user_info` to see how many users are active. If that number is close to the limit, run `get_capacity_limit` first. This tells you your current operational boundaries. **Is there a tool in Tencent START MCP Server to handle scaling?** Yes, use `modify_capacity_limit`. This tool updates the maximum user count for a game ID when demand requires it. It's how you prevent service slowdowns. **What's the difference between list_workers and get_worker_info?** `list_workers` gives you an inventory—a broad overview of all worker instances and their general status. `get_worker_info` is specific; it drills down to get detailed metrics for one single, known user's worker. **How do I start a game session programmatically?** You use the `create_session` tool. This initializes the cloud gaming instance and makes it ready for the user to connect to. **What credentials do I need to use the `try_lock_worker` tool?** You must provide a valid SecretId, SecretKey, and Region for authentication. These are generated in your Tencent Cloud Console after enabling the Cloud Gaming (GS) service. Your AI client uses these keys to authorize session locking requests. **When should I use `stop_game` versus `stop_publish_stream`?** `stop_game` fully terminates a game instance, releasing all associated resources and workers. Use `stop_publish_stream`, however, if you only need to cut the video feed for a specific user while keeping the underlying worker active. **What does the `list_games` tool provide about the Tencent GS platform?** The `list_games` tool returns a catalog of all available game IDs on the platform. This is essential for determining which titles you can target before attempting to monitor or create sessions. **How do I ensure I have the right parameters for `modify_capacity_limit`?** The tool requires two main inputs: a specific game ID and the new maximum concurrency limit. You must know both values to successfully update the capacity ceiling for that particular title. **Can I automatically list all available games on the platform?** Yes! Use the `list_games` tool. It will retrieve metadata for all configured cloud games, including their names and unique identifiers. **How do I check the status of my cloud gaming workers?** Use the `list_workers` tool. It returns the availability and current operational state of all server instances allocated to your account. **Can I dynamically modify the concurrency limit for a game?** Yes! Use the `modify_capacity_limit` tool with the target Game ID and the new maximum concurrent user count to scale your capacity.