DeleteInstances

Instructions

Implementation Reference

• src/alibaba_cloud_ops_mcp_server/config.py:7-25 (registration)

  Configuration defining the list of ECS APIs to register as MCP tools, including 'DeleteInstances'.

  config = {
      'ecs': [
          'DescribeInstances',
          'DescribeRegions',
          'DescribeZones',
          'DescribeAccountAttributes',
          'DescribeAvailableResource',
          'DescribeImages',
          'DescribeSecurityGroups',
          'DeleteInstances'
      ],
      'Vpc': [
          'DescribeVpcs',
          'DescribeVSwitches'
      ],
      'rds': [
          'DescribeDBInstances'
      ]
  }

• src/alibaba_cloud_ops_mcp_server/server.py:88-88 (registration)

  Triggers the registration of dynamic API tools by calling create_api_tools with the config that includes DeleteInstances.

  api_tools.create_api_tools(mcp, config)

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:267-271 (registration)

  Registers a dynamic MCP tool for each API listed in config, including ECS_DeleteInstances based on 'DeleteInstances'.

  def create_api_tools(mcp: FastMCP, config:dict):
      for service_code, apis in config.items():
          for api_name in apis:
              _create_and_decorate_tool(mcp, service_code, api_name)

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:142-202 (schema)

  Dynamically generates the input schema (Pydantic dataclass fields) for the tool from the API metadata retrieved for DeleteInstances.

  def _create_function_schemas(service, api, api_meta):
      schemas = {}
      schemas[api] = {}
      parameters = api_meta.get('parameters', [])
  
      required_params = []
      optional_params = []
  
      for parameter in parameters:
          name = parameter.get('name')
          # TODO 目前忽略了带'.'的参数
          if '.' in name:
              continue
          schema = parameter.get('schema', '')
          required = schema.get('required', False)
  
          if required:
              required_params.append(parameter)
          else:
              optional_params.append(parameter)
  
      def process_parameter(parameter):
          name = parameter.get('name')
          schema = parameter.get('schema', '')
          description = schema.get('description', '')
          example = schema.get('example', '')
          type_ = schema.get('type', '')
          description = f'{description} 参数类型: {type_},参数示例：{example}'
          required = schema.get('required', False)
  
          if service.lower() == 'ecs' and name in ECS_LIST_PARAMETERS and type_ == 'string':
              python_type = list
          else:
              python_type = type_map.get(type_, str)
  
          field_info = (
              python_type,
              field(
                  default=None,
                  metadata={'description': description, 'required': required}
              )
          )
          return name, field_info
  
      for parameter in required_params:
          name, field_info = process_parameter(parameter)
          schemas[api][name] = field_info
  
      for parameter in optional_params:
          name, field_info = process_parameter(parameter)
          schemas[api][name] = field_info
  
      if 'RegionId' not in schemas[api]:
          schemas[api]['RegionId'] = (
              str,
              field(
                  default='cn-hangzhou',
                  metadata={'description': '地域ID', 'required': False}
              )
          )
      return schemas

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:100-135 (handler)

  Executes the actual Alibaba Cloud API call for service='ecs' and api='DeleteInstances' with the provided parameters, handling specifics like endpoint and ECS list parameters.

  def _tools_api_call(service: str, api: str, parameters: dict, ctx: Context):
      service = service.lower()
      api_meta, _ = ApiMetaClient.get_api_meta(service, api)
      version = ApiMetaClient.get_service_version(service)
      method = 'POST' if api_meta.get('methods', [])[0] == 'post' else 'GET'
      path = api_meta.get('path', '/')
      style = ApiMetaClient.get_service_style(service)
      
      # Handling special parameter formats
      processed_parameters = parameters.copy()
      processed_parameters = {k: v for k, v in processed_parameters.items() if v is not None}
      if service == 'ecs':
          for param_name, param_value in parameters.items():
              if param_name in ECS_LIST_PARAMETERS and isinstance(param_value, list):
                  processed_parameters[param_name] = json.dumps(param_value)
      
      req = open_api_models.OpenApiRequest(
          query=OpenApiUtilClient.query(processed_parameters)
      )
      params = open_api_models.Params(
          action=api,
          version=version,
          protocol='HTTPS',
          pathname=path,
          method=method,
          auth_type='AK',
          style=style,
          req_body_type='formData',
          body_type='json'
      )
      logger.info(f'Call API Request: Service: {service} API: {api} Method: {method} Parameters: {processed_parameters}')
      client = create_client(service, processed_parameters.get('RegionId', 'cn-hangzhou'))
      runtime = util_models.RuntimeOptions()
      resp = client.call_api(params, req, runtime)
      logger.info(f'Call API Response: {resp}')
      return resp