mcp-server

keboola/mcp-server

3.9

Keboola MCP Server connects AI agents and MCP clients to Keboola, enabling data access and transformations without glue code.

Tools
31
Resources
0
Prompts
6

Ask DeepWiki smithery badge

Keboola MCP Server

Connect your AI agents, MCP clients (Cursor, Claude, Windsurf, VS Code ...) and other AI assistants to Keboola. Expose data, transformations, SQL queries, and job triggers—no glue code required. Deliver the right data to agents when and where they need it.

Overview

Keboola MCP Server is an open-source bridge between your Keboola project and modern AI tools. It turns Keboola features—like storage access, SQL transformations, and job triggers—into callable tools for Claude, Cursor, CrewAI, LangChain, Amazon Q, and more.

🚀 Quick Start: Remote MCP Server (Easiest Way)

The easiest way to use Keboola MCP Server is through our Remote MCP Server. This hosted solution eliminates the need for local setup, configuration, or installation.

What is the Remote MCP Server?

Our remote server is hosted on every multi-tenant Keboola stack and supports OAuth authentication. You can connect to it from any AI assistant that supports remote SSE connection and OAuth authentication.

How to Connect

  1. Get your remote server URL: Navigate to your Keboola Project Settings → MCP Server tab
  2. Copy the server URL: It will look like https://mcp.<YOUR_REGION>.keboola.com/sse
  3. Configure your AI assistant: Paste the URL into your AI assistant's MCP settings
  4. Authenticate: You'll be prompted to authenticate with your Keboola account and select your project

Supported Clients

  • Cursor: Use the "Install In Cursor" button in your project's MCP Server settings or click this button Install MCP Server
  • Claude Desktop: Add the integration via Settings → Integrations
  • Windsurf: Configure with the remote server URL
  • Make: Configure with the remote server URL
  • Other MCP clients: Configure with the remote server URL

For detailed setup instructions and region-specific URLs, see our Remote Server Setup documentation.


Features

  • Storage: Query tables directly and manage table or bucket descriptions
  • Components: Create, List and inspect extractors, writers, data apps, and transformation configurations
  • SQL: Create SQL transformations with natural language
  • Jobs: Run components and transformations, and retrieve job execution details
  • Metadata: Search, read, and update project documentation and object metadata using natural language

Preparations

Make sure you have:

  • Python 3.10+ installed
  • Access to a Keboola project with admin rights
  • Your preferred MCP client (Claude, Cursor, etc.)

Note: Make sure you have uv installed. The MCP client will use it to automatically download and run the Keboola MCP Server. Installing uv:

macOS/Linux:

#if homebrew is not installed on your machine use:
# /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install using Homebrew
brew install uv

Windows:

# Using the installer script
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or using pip
pip install uv

# Or using winget
winget install --id=astral-sh.uv -e

For more installation options, see the official uv documentation.

Before setting up the MCP server, you need three key pieces of information:

KBC_STORAGE_TOKEN

This is your authentication token for Keboola:

For instructions on how to create and manage Storage API tokens, refer to the official Keboola documentation.

Note: If you want the MCP server to have limited access, use custom storage token, if you want the MCP to access everything in your project, use the master token.

KBC_WORKSPACE_SCHEMA

This identifies your workspace in Keboola and is used for SQL queries. However, this is only required if you're using a custom storage token instead of the Master Token:

Note: When creating a workspace manually, check Grant read-only access to all Project data option

Note: KBC_WORKSPACE_SCHEMA is called Dataset Name in BigQuery workspaces, you simply click connect and copy the Dataset Name

Keboola Region

Your Keboola API URL depends on your deployment region. You can determine your region by looking at the URL in your browser when logged into your Keboola project:

RegionAPI URL
AWS North Americahttps://connection.keboola.com
AWS Europehttps://connection.eu-central-1.keboola.com
Google Cloud EUhttps://connection.europe-west3.gcp.keboola.com
Google Cloud UShttps://connection.us-east4.gcp.keboola.com
Azure EUhttps://connection.north-europe.azure.keboola.com

Running Keboola MCP Server

There are four ways to use the Keboola MCP Server, depending on your needs:

Option A: Integrated Mode (Recommended)

In this mode, Claude or Cursor automatically starts the MCP server for you. You do not need to run any commands in your terminal.

  1. Configure your MCP client (Claude/Cursor) with the appropriate settings
  2. The client will automatically launch the MCP server when needed
Claude Desktop Configuration
  1. Go to Claude (top left corner of your screen) -> Settings → Developer → Edit Config (if you don't see the claude_desktop_config.json, create it)
  2. Add the following configuration:
  3. Restart Claude desktop for changes to take effect
{
  "mcpServers": {
    "keboola": {
      "command": "uvx",
      "args": ["keboola_mcp_server"],
      "env": {
        "KBC_STORAGE_API_URL": "https://connection.YOUR_REGION.keboola.com",
        "KBC_STORAGE_TOKEN": "your_keboola_storage_token",
        "KBC_WORKSPACE_SCHEMA": "your_workspace_schema"
      }
    }
  }
}

Config file locations:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
Cursor Configuration
  1. Go to Settings → MCP
  2. Click "+ Add new global MCP Server"
  3. Configure with these settings:
{
  "mcpServers": {
    "keboola": {
      "command": "uvx",
      "args": ["keboola_mcp_server"],
      "env": {
        "KBC_STORAGE_API_URL": "https://connection.YOUR_REGION.keboola.com",
        "KBC_STORAGE_TOKEN": "your_keboola_storage_token",
        "KBC_WORKSPACE_SCHEMA": "your_workspace_schema"
      }
    }
  }
}

Note: Use short, descriptive names for MCP servers. Since the full tool name includes the server name and must stay under ~60 characters, longer names may be filtered out in Cursor and will not be displayed to the Agent.

Cursor Configuration for Windows WSL

When running the MCP server from Windows Subsystem for Linux with Cursor AI, use this configuration:

{
  "mcpServers": {
    "keboola":{
      "command": "wsl.exe",
      "args": [
          "bash",
          "-c '",
          "export KBC_STORAGE_API_URL=https://connection.YOUR_REGION.keboola.com &&",
          "export KBC_STORAGE_TOKEN=your_keboola_storage_token &&",
          "export KBC_WORKSPACE_SCHEMA=your_workspace_schema &&",
          "/snap/bin/uvx keboola_mcp_server",
          "'"
      ]
    }
  }
}

Option B: Local Development Mode

For developers working on the MCP server code itself:

  1. Clone the repository and set up a local environment
  2. Configure Claude/Cursor to use your local Python path:
{
  "mcpServers": {
    "keboola": {
      "command": "/absolute/path/to/.venv/bin/python",
      "args": [
        "-m",
        "keboola_mcp_server"
      ],
      "env": {
        "KBC_STORAGE_API_URL": "https://connection.YOUR_REGION.keboola.com",
        "KBC_STORAGE_TOKEN": "your_keboola_storage_token",
        "KBC_WORKSPACE_SCHEMA": "your_workspace_schema"
      }
    }
  }
}

Option C: Manual CLI Mode (For Testing Only)

You can run the server manually in a terminal for testing or debugging:

# Set environment variables
export KBC_STORAGE_API_URL=https://connection.YOUR_REGION.keboola.com
export KBC_STORAGE_TOKEN=your_keboola_storage_token
export KBC_WORKSPACE_SCHEMA=your_workspace_schema

uvx keboola_mcp_server --transport sse

Note: This mode is primarily for debugging or testing. For normal use with Claude or Cursor, you do not need to manually run the server.

Note: The server will use the SSE transport and listen on localhost:8000 for the incoming SSE connections. You can use --port and --host parameters to make it listen elsewhere.

Option D: Using Docker

docker pull keboola/mcp-server:latest

docker run \
  --name keboola_mcp_server \
  --rm \
  -it \
  -p 127.0.0.1:8000:8000 \
  -e KBC_STORAGE_API_URL="https://connection.YOUR_REGION.keboola.com" \
  -e KBC_STORAGE_TOKEN="YOUR_KEBOOLA_STORAGE_TOKEN" \
  -e KBC_WORKSPACE_SCHEMA="YOUR_WORKSPACE_SCHEMA" \
  keboola/mcp-server:latest \
  --transport sse \
  --host 0.0.0.0

Note: The server will use the SSE transport and listen on localhost:8000 for the incoming SSE connections. You can change -p to map the container's port somewhere else.

Do I Need to Start the Server Myself?

ScenarioNeed to Run Manually?Use This Setup
Using Claude/CursorNoConfigure MCP in app settings
Developing MCP locallyNo (Claude starts it)Point config to python path
Testing CLI manuallyYesUse terminal to run
Using DockerYesRun docker container

Using MCP Server

Once your MCP client (Claude/Cursor) is configured and running, you can start querying your Keboola data:

Verify Your Setup

You can start with a simple query to confirm everything is working:

What buckets and tables are in my Keboola project?

Examples of What You Can Do

Data Exploration:

  • "What tables contain customer information?"
  • "Run a query to find the top 10 customers by revenue"

Data Analysis:

  • "Analyze my sales data by region for the last quarter"
  • "Find correlations between customer age and purchase frequency"

Data Pipelines:

  • "Create a SQL transformation that joins customer and order tables"
  • "Start the data extraction job for my Salesforce component"

Compatibility

MCP Client Support

MCP ClientSupport StatusConnection Method
Claude (Desktop & Web)✅ supportedstdio
Cursor✅ supportedstdio
Windsurf, Zed, Replit✅ Supportedstdio
Codeium, Sourcegraph✅ SupportedHTTP+SSE
Custom MCP Clients✅ SupportedHTTP+SSE or stdio

Supported Tools

Note: Your AI agents will automatically adjust to new tools.

CategoryToolDescription
Projectget_project_infoReturns structured information about your Keboola project
Storageget_bucketGets detailed information about a specific bucket
get_tableGets detailed information about a specific table, including DB identifier and columns
list_bucketsRetrieves all buckets in the project
list_tablesRetrieves all tables in a specific bucket
update_descriptionUpdates description for a bucket, table, or column
SQLget_sql_dialectReturns the SQL dialect used by the workspace
query_dataExecutes a SELECT query against the underlying database
Componentadd_config_rowCreates a configuration row for a component configuration
create_configCreates a root component configuration
create_sql_transformationCreates an SQL transformation from one or more SQL code blocks
find_component_idFinds component IDs matching a natural-language query
get_componentRetrieves details of a component by ID
get_configRetrieves a specific component/transformation configuration
get_config_examplesRetrieves example configurations for a component
list_configsLists configurations in the project, optionally filtered
list_transformationsLists transformation configurations in the project
update_configUpdates a root component configuration
update_config_rowUpdates a component configuration row
update_sql_transformationUpdates an existing SQL transformation configuration
Flowcreate_conditional_flowCreates a conditional flow (keboola.flow)
create_flowCreates a legacy flow (keboola.orchestrator)
get_flowRetrieves details of a specific flow configuration
get_flow_examplesRetrieves examples of valid flow configurations
get_flow_schemaReturns the JSON schema for the specified flow type
list_flowsLists flow configurations in the project
update_flowUpdates an existing flow configuration
Jobsget_jobRetrieves detailed information about a specific job
list_jobsLists jobs with optional filtering, sorting, and pagination
run_jobStarts a job for a component or transformation
Documentationdocs_queryAnswers questions using Keboola documentation as the source
Othercreate_oauth_urlGenerates an OAuth authorization URL for a component configuration
searchSearches for items in the project by name prefixes

Troubleshooting

Common Issues

IssueSolution
Authentication ErrorsVerify KBC_STORAGE_TOKEN is valid
Workspace IssuesConfirm KBC_WORKSPACE_SCHEMA is correct
Connection TimeoutCheck network connectivity

Development

Installation

Basic setup:

uv sync --extra dev

With the basic setup, you can use uv run tox to run tests and check code style.

Recommended setup:

uv sync --extra dev --extra tests --extra integtests --extra codestyle

With the recommended setup, packages for testing and code style checking will be installed which allows IDEs like VsCode or Cursor to check the code or run tests during development.

Integration tests

To run integration tests locally, use uv run tox -e integtests. NOTE: You will need to set the following environment variables:

  • INTEGTEST_STORAGE_API_URL
  • INTEGTEST_STORAGE_TOKEN
  • INTEGTEST_WORKSPACE_SCHEMA

In order to get these values, you need a dedicated Keboola project for integration tests.

Updating uv.lock

Update the uv.lock file if you have added or removed dependencies. Also consider updating the lock with newer dependency versions when creating a release (uv lock --upgrade).

Updating Tool Documentation

When you make changes to any tool descriptions (docstrings in tool functions), you must regenerate the TOOLS.md documentation file to reflect these changes:

uv run python -m src.keboola_mcp_server.generate_tool_docs

Support and Feedback

⭐ The primary way to get help, report bugs, or request features is by opening an issue on GitHub. ⭐

The development team actively monitors issues and will respond as quickly as possible. For general information about Keboola, please use the resources below.

Resources

Connect