delete_metabase_card

Instructions

Implementation Reference

• src/metabase_mcp_server.py:659-671 (handler)

  The main handler function for delete_metabase_card tool. It's decorated with @mcp.tool() to register it as an MCP tool. The async function takes a card_id parameter and calls make_metabase_request with RequestMethod.DELETE to delete the card from Metabase via the /api/card/{card_id} endpoint.

  @mcp.tool()
  async def delete_metabase_card(card_id: int) -> Dict[str, Any]:
      """
      Delete a card from Metabase.
  
      Args:
          card_id (int): ID of the card to delete.
  
      Returns:
          Dict[str, Any]: Deletion confirmation.
      """
      logger.info(f"Deleting card {card_id}")
      return await make_metabase_request(RequestMethod.DELETE, f"/api/card/{card_id}")

• src/metabase_mcp_server.py:162-220 (helper)

  Helper function make_metabase_request that executes HTTP requests to the Metabase API. It handles request construction, error handling, and response parsing. Used by delete_metabase_card to make the actual DELETE request to Metabase.

  async def make_metabase_request(
      method: RequestMethod,
      endpoint: str,
      data: Optional[Dict[str, Any] | bytes] = None,
      params: Optional[Dict[str, Any]] = None,
      json: Any = None,
      headers: Optional[Dict[str, str]] = None,
  ) -> Dict[str, Any]:
      """
      Make a request to the Metabase API.
      
      Args:
          method: HTTP method to use (GET, POST, PUT, DELETE)
          endpoint: API endpoint path
          data: Request data (for form data)
          params: URL parameters
          json: JSON request body
          headers: Additional headers
          
      Returns:
          Dict[str, Any]: Response data
          
      Raises:
          MetabaseConnectionError: When the Metabase server is unreachable
          MetabaseResponseError: When Metabase returns a non-2xx status code
          RuntimeError: For other errors
      """
      
      if not METABASE_URL or not METABASE_API_KEY:
          raise RuntimeError("METABASE_URL or METABASE_API_KEY environment variable is not set. Metabase API requests will fail.")
  
      if session is None:
          raise RuntimeError("HTTP session is not initialized. Ensure app_lifespan was called.")
  
      try:
          request_headers = headers or {}
          
          logger.debug(f"Making {method.name} request to {METABASE_URL}{endpoint}")
          
          # Log request payload for debugging (omit sensitive info)
          if json and logger.level <= logging.DEBUG:
              sanitized_json = {**json}
              if 'password' in sanitized_json:
                  sanitized_json['password'] = '********'
              logger.debug(f"Request payload: {sanitized_json}")
              
          response = await session.request(
              method=method.name,
              url=endpoint,
              timeout=aiohttp.ClientTimeout(total=30),
              headers=request_headers,
              data=data,
              params=params,
              json=json,
          )
  
          try:
              # Handle 500 errors with more detailed info
              if response.status >= 500:

• src/metabase_mcp_server.py:160-160 (registration)

  Creation of the FastMCP server instance named 'metabase' with a lifespan manager. This is the MCP server that all @mcp.tool() decorated functions are registered with, including delete_metabase_card.

  mcp = FastMCP("metabase", lifespan=app_lifespan)

• src/enums/request_enum.py:1-11 (schema)

  RequestMethod enum defining HTTP methods (GET, POST, PUT, DELETE). Used by delete_metabase_card to specify RequestMethod.DELETE when calling make_metabase_request. Provides type-safe HTTP method constants.

  from enum import Enum, auto
  
  class RequestMethod(Enum):
      GET = auto()
      POST = auto()
      PUT = auto()
      DELETE = auto()
  
      def __str__(self):
          return self.name