Supabase MCP Server Kd5

🚀 Supabase MCP Server

A Model Context Protocol (MCP) server that provides tools for interacting with a Supabase database. This server enables AI assistants to perform database operations through a standardized interface.

⚠️ Important Note

This Supabase MCP server is an example I demonstrated in the videos on my YouTube channel to showcase my AI IDE coding workflow. It's still a work in progress, and I'll continue to expand and improve it in the future.

✨ Features

• Read Table Rows: Query data from Supabase tables with optional filtering, pagination, and column selection.
• Create Table Records: Insert new records into Supabase tables.
• Update Table Records: Modify existing records based on filtering conditions.
• Delete Table Records: Delete records based on filtering conditions.

📦 Prerequisites

• Docker or Docker Desktop
• A Supabase account and project

📦 Installation

1. Clone the repository:

   git clone https://github.com/coleam00/supabase-mcp.git
   cd supabase-mcp
   

💻 Usage Examples

Docker Setup

1. Build the Docker image:

   FROM python:3.8-slim
   WORKDIR /app
   COPY requirements.txt .
   RUN pip install -r requirements.txt
   COPY . .
   EXPOSE 5000
   CMD ["python", "server.py"]
   

2. Run the Docker container:

   docker build -t mcp/supabase .
   docker run -e SUPABASE_URL=your-supabase-url -e SUPABASE_SERVICE_KEY=your-service-role-key -it mcp/supabase
   

Available Tools

Basic Usage

# Read Table Rows
def read_table_records(table_name: str, 
                      column_names: List[str] = ["*"], 
                      filter_conditions: Optional[List[Tuple[str, str, str]]] = None,
                      page: int = 1,
                      per_page: int = 10) -> Dict:
    """
    Read records from the specified table.
    
    Args:
        table_name (str): Name of the table.
        column_names (List[str]): Names of columns to return, default is ["*"] which means all columns.
        filter_conditions (Optional[List[Tuple[str, str, str]]]): List of filtering conditions, each tuple contains (column, operator, value).
        page (int): Current page number, default is 1.
        per_page (int): Number of records per page, default is 10.
    
    Returns:
        Dict: A dictionary containing query results, total number of records, and pagination information.
    """

# Create Table Record
def create_table_record(table_name: str, 
                      record_data: Dict[str, Any]) -> bool:
    """
    Insert a new record into the specified table.
    
    Args:
        table_name (str): Name of the table.
        record_data (Dict[str, Any]): Data dictionary of the new record.
        
    Returns:
        bool: Whether the operation was successful.
    """

# Update Table Record
def update_table_record(table_name: str,
                      filter_conditions: List[Tuple[str, str, str]],
                      update_data: Dict[str, Any]) -> int:
    """
    Update records in the specified table based on filtering conditions.
    
    Args:
        table_name (str): Name of the table.
        filter_conditions (List[Tuple[str, str, str]]): List of filtering conditions, each tuple contains (column, operator, value).
        update_data (Dict[str, Any]): Data dictionary to be updated.
        
    Returns:
        int: Number of updated records.
    """

# Delete Table Records
def delete_table_records(table_name: str,
                      filter_conditions: List[Tuple[str, str, str]]) -> int:
    """
    Delete records from the specified table based on filtering conditions.
    
    Args:
        table_name (str): Name of the table.
        filter_conditions (List[Tuple[str, str, str]]): List of filtering conditions, each tuple contains (column, operator, value).
        
    Returns:
        int: Number of deleted records.
    """

📚 Documentation

Project Structure

supabase-mcp/
├── server.py              # Entry point of the MCP server
├── requirements.txt      # Dependency management
└── docker/Dockerfile     # Docker image configuration

Testing

1. Run test cases:

   pytest tests/
   

2. Generate a coverage report:

   coverage run -m pytest tests/ && coverage report
   

Protocol Integration

How it Works

1. The MCP server provides database operation tools (read, create, update, delete).
2. The AI assistant connects to the MCP server via stdio transport.
3. The AI assistant can call the tools to perform database operations.
4. The MCP server handles communication with Supabase and returns the results.

Configuration Example

{
  "mcpServers": {
    "supabase": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "SUPABASE_URL", "-e", "SUPABASE_SERVICE_KEY", "mcp/supabase"],
      "env": {
        "SUPABASE_URL": "YOUR-SUPABASE-URL",
        "SUPABASE_SERVICE_KEY": "YOUR-SERVICE-ROLE-KEY"
      }
    }
  }
}

Environment Variables

📄 License

MIT License

Contributors

• [Your Name] - Initial development