Superset MCP Integration

Instructions

Implementation Reference

• main.py:994-1014 (handler)

  Handler function decorated with @mcp.tool() that implements the tool by making an authenticated GET request to Superset API endpoint /api/v1/database/{database_id}/function_names/ using the shared make_api_request helper.

  @mcp.tool()
  @requires_auth
  @handle_api_errors
  async def superset_database_get_function_names(
      ctx: Context, database_id: int
  ) -> Dict[str, Any]:
      """
      Get function names supported by a database
  
      Makes a request to the /api/v1/database/{id}/function_names/ endpoint to retrieve
      all SQL functions supported by the database.
  
      Args:
          database_id: ID of the database
  
      Returns:
          A dictionary with list of supported function names
      """
      return await make_api_request(
          ctx, "get", f"/api/v1/database/{database_id}/function_names/"
      )

• main.py:994-994 (registration)

  The @mcp.tool() decorator registers this function as an MCP tool.

  @mcp.tool()

• main.py:271-330 (helper)

  Shared helper function used by the tool to make authenticated API requests to Superset, handling token refresh, CSRF, and error handling.

  async def make_api_request(
      ctx: Context,
      method: str,
      endpoint: str,
      data: Dict[str, Any] = None,
      params: Dict[str, Any] = None,
      auto_refresh: bool = True,
  ) -> Dict[str, Any]:
      """
      Helper function to make API requests to Superset
  
      Args:
          ctx: MCP context
          method: HTTP method (get, post, put, delete)
          endpoint: API endpoint (without base URL)
          data: Optional JSON payload for POST/PUT requests
          params: Optional query parameters
          auto_refresh: Whether to auto-refresh token on 401
      """
      superset_ctx: SupersetContext = ctx.request_context.lifespan_context
      client = superset_ctx.client
  
      # For non-GET requests, make sure we have a CSRF token
      if method.lower() != "get" and not superset_ctx.csrf_token:
          await get_csrf_token(ctx)
  
      async def make_request() -> httpx.Response:
          headers = {}
  
          # Add CSRF token for non-GET requests
          if method.lower() != "get" and superset_ctx.csrf_token:
              headers["X-CSRFToken"] = superset_ctx.csrf_token
  
          if method.lower() == "get":
              return await client.get(endpoint, params=params)
          elif method.lower() == "post":
              return await client.post(
                  endpoint, json=data, params=params, headers=headers
              )
          elif method.lower() == "put":
              return await client.put(endpoint, json=data, headers=headers)
          elif method.lower() == "delete":
              return await client.delete(endpoint, headers=headers)
          else:
              raise ValueError(f"Unsupported HTTP method: {method}")
  
      # Use auto_refresh if requested
      response = (
          await with_auto_refresh(ctx, make_request)
          if auto_refresh
          else await make_request()
      )
  
      if response.status_code not in [200, 201]:
          return {
              "error": f"API request failed: {response.status_code} - {response.text}"
          }
  
      return response.json()