Skip to main content
Glama
aliyun

Alibaba Cloud DMS MCP Server

Official
by aliyun

optimizeSql

Read-only

Analyze and optimize SQL performance by identifying bottlenecks and suggesting improvements for enhanced database query efficiency.

Instructions

Analyze and optimize SQL performance based on the provided SQL statement and database IDIf you don't know the databaseId, first use getDatabase or searchDatabase to retrieve it. (1) If you have the exact host, port, and database name, use getDatabase. (2) If you only know the database name, use searchDatabase. (3) If you don't know any information, ask the user to provide the necessary details. Note: searchDatabase may return multiple databases. In this case, let the user choose which one to use.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
database_idYesDMS databaseId
questionNoNatural language question
sqlYesSQL statement
modelNoOptional: if a specific model is desired, it can be specified here

Implementation Reference

  • Core handler function 'optimize_sql' that invokes the Alibaba Cloud DMS Enterprise API method 'optimize_sql_by_meta_agent' to analyze and optimize the provided SQL statement for the specified database.
    async def optimize_sql(
            database_id: str = Field(description="DMS databaseId"),
            question: Optional[str] = Field(default=None, description="Natural language question"),
            sql: str = Field(description="SQL statement"),
            model: Optional[str] = Field(default=None,
                                         description="Optional: if a specific model is desired, it can be specified here")
    ) -> Any:
        client = create_client()
        req = dms_enterprise_20181101_models.OptimizeSqlByMetaAgentRequest(db_id=database_id, query=question, sql=sql)
        # if mcp.state.real_login_uid:
        #     req.real_login_user_uid = mcp.state.real_login_uid
        if model:
            req.model = model
        try:
            resp = client.optimize_sql_by_meta_agent(req)
            if not resp or not resp.body:
                return None
            data = resp.body.to_map()
            return data
        except Exception as e:
            logger.error(f"Error in optimize_sql: {e}")
            raise
  • Registration of 'optimizeSql' tool in the configured database toolset (when default_database_id is set). This wrapper calls the core 'optimize_sql' handler with the pre-configured database ID.
    @self.mcp.tool(name="optimizeSql",
                   description="Analyze and optimize SQL performance based on the provided SQL statement",
                   annotations={"title": "SQL优化", "readOnlyHint": True, "destructiveHint": False})
    async def optimize_sql_configured(
            question: Optional[str] = Field(default=None, description="Natural language question"),
            sql: str = Field(description="SQL statement"),
            model: Optional[str] = Field(default=None,
                                         description="Optional: if a specific model is desired, it can be specified here")
    ) -> Any:
        result_obj = await optimize_sql(database_id=self.default_database_id, question=question, sql=sql,
                                        model=model)
        return result_obj
  • Direct registration of the core 'optimize_sql' handler as the 'optimizeSql' tool in the full toolset (when no default database is configured). Requires explicit database_id parameter.
    self.mcp.tool(name="optimizeSql", description=f"Analyze and optimize SQL performance "
                                                  f"based on the provided SQL statement and database ID"
                                                  f"{DATABASE_ID_DESCRIPTION}",
                  annotations={"title": "SQL优化", "readOnlyHint": True})(optimize_sql)
Behavior3/5

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

The annotations already declare readOnlyHint=true, indicating this is a safe read operation. The description adds useful context about the need for database identification and the multi-step process to obtain it, but doesn't disclose other behavioral traits like what 'optimize' entails (e.g., suggestions vs. execution), performance characteristics, or rate limits. No contradiction with annotations exists.

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 appropriately sized and front-loaded with the core purpose in the first sentence. The subsequent guidance is necessary but could be slightly more concise. Each sentence earns its place by providing valuable usage instructions, though the numbered list format adds some verbosity.

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 (SQL optimization), the description is reasonably complete. It covers the core purpose, prerequisites, and alternative tools. With annotations covering safety (readOnlyHint) and 100% schema coverage, the main gap is the lack of output schema, but the description doesn't need to explain return values. The guidance on database identification addresses a key contextual requirement.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema already fully documents all four parameters. The description mentions 'database_id' and 'sql' as required inputs but doesn't add meaning beyond what the schema provides for 'question' or 'model' parameters. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Analyze and optimize SQL performance based on the provided SQL statement and database ID'. This specifies both the verb ('analyze and optimize') and resource ('SQL performance'), making it clear what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'fixSql' or 'answerSqlSyntax', which might have overlapping functionality.

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

Usage Guidelines5/5

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

The description provides excellent usage guidance with explicit instructions on when to use this tool versus alternatives. It specifies prerequisites (needing databaseId), directs users to 'getDatabase' or 'searchDatabase' if they don't have it, and explains the difference between these alternatives. It also includes guidance for when no information is available ('ask the user').

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-dms-mcp-server'

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