Skip to main content
Glama
aliyun

Alibaba Cloud RDS OpenAPI MCP Server

Official
by aliyun

describe_db_instance_parameters

Read-only

Retrieve parameter configurations for multiple Alibaba Cloud RDS database instances to monitor and manage database settings across your infrastructure.

Instructions

Batch retrieves parameter information for multiple RDS instances.
Args:
    region_id: The region ID of the RDS instance.
    db_instance_ids: List of DB instance identifiers (e.g., ["rm-uf6wjk5****", "db-instance-01"])
    paramters: List of parameter names (e.g., ["max_connections", "innodb_buffer_pool_size"])
Returns:
    list[dict]: A list of dictionaries containing parameter information(ParamGroupInfo,ConfigParameters,RunningParameters) foreach instance.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
region_idYes
db_instance_idsYes
paramtersNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • The handler implementation for the 'describe_db_instance_parameters' tool. It uses the Alibaba Cloud RDS SDK (DescribeParametersRequest) to fetch configuration and running parameters for specified DB instances, optionally filtering by parameter names. Returns structured data including parameter group info and CSV-formatted parameter lists.
    async def describe_db_instance_parameters(
            region_id: str,
            db_instance_ids: list[str],
            paramters: list[str] = None
    ) -> dict[str, dict[str, Any]]:
        """
        Batch retrieves parameter information for multiple RDS instances.
        Args:
            region_id: The region ID of the RDS instance.
            db_instance_ids: List of DB instance identifiers (e.g., ["rm-uf6wjk5****", "db-instance-01"])
            paramters: List of parameter names (e.g., ["max_connections", "innodb_buffer_pool_size"])
        Returns:
            list[dict]: A list of dictionaries containing parameter information(ParamGroupInfo,ConfigParameters,RunningParameters) foreach instance.
        """
        try:
            client = get_rds_client(region_id)
            db_instance_parameters = {}
            for db_instance_id in db_instance_ids:
                request = rds_20140815_models.DescribeParametersRequest(
                    dbinstance_id=db_instance_id
                )
                response = await client.describe_parameters_async(request)
                if paramters:
                    response.body.config_parameters.dbinstance_parameter = [
                        config_parameter for config_parameter in response.body.config_parameters.dbinstance_parameter
                        if config_parameter.parameter_name in paramters
                    ]
                    response.body.running_parameters.dbinstance_parameter = [
                        running_parameter for running_parameter in response.body.running_parameters.dbinstance_parameter
                        if running_parameter.parameter_name in paramters
                    ]
    
                    db_instance_parameters[db_instance_id] = {
                        "ParamGroupInfo": response.body.param_group_info.to_map(),
                        "ConfigParameters": json_array_to_csv(response.body.config_parameters.dbinstance_parameter),
                        "RunningParameters": json_array_to_csv(response.body.running_parameters.dbinstance_parameter)
                    }
            return db_instance_parameters
        except Exception as e:
            raise e
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate readOnlyHint=true, which the description aligns with by using 'retrieves' (implying read-only). The description adds context about batch retrieval for multiple instances, which is useful behavioral information not covered by annotations. However, it doesn't disclose rate limits, authentication needs, or error conditions, leaving gaps in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting for parameters. It's front-loaded with the core purpose and avoids unnecessary details. However, the typo in 'paramters' and slightly verbose return explanation slightly reduce efficiency, but overall it's concise and effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (batch retrieval with 3 parameters), the description covers the purpose and parameters adequately. With annotations providing read-only context and an output schema likely detailing the return structure, the description doesn't need to explain return values deeply. It's complete enough for basic understanding, though it could benefit from more usage guidelines.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description compensates by explaining all three parameters: region_id, db_instance_ids, and paramters (note typo). It provides examples for db_instance_ids and paramters, clarifying their formats and purposes. This adds significant value beyond the bare schema, though it doesn't detail constraints like valid region IDs or parameter name formats.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Batch retrieves parameter information') and resource ('for multiple RDS instances'), distinguishing it from siblings like describe_db_instance_attribute or describe_db_instance_performance. It explicitly mentions what information is retrieved (parameter information), making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like describe_db_instance_attribute or modify_parameter. It lacks context about prerequisites, such as needing specific permissions or instance states, and doesn't mention any exclusions or limitations, leaving usage decisions unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/aliyun/alibabacloud-rds-openapi-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server