---
title: "ClickHouse MCP Server: SQL Analytics from Claude and Cursor"
url: "https://mcpshelf.co/servers/clickhouse"
description: "ClickHouse's own MCP server runs read-only SQL on your cluster, lists databases and tables, and can query files with chDB. Config, write flags, free demo."
updated: "2026-11-10"
site: "MCP Shelf"
---

# ClickHouse MCP Server

> ClickHouse's own server: read-only SQL on your cluster, plus chDB for local files.

Source: https://mcpshelf.co/servers/clickhouse  
Markdown: https://mcpshelf.co/servers/clickhouse.md  
Generated: 2026-11-22T13:57:58.284Z

## Facts

- **Name:** ClickHouse MCP Server
- **Tagline:** ClickHouse's own server: read-only SQL on your cluster, plus chDB for local files.
- **Description:** ClickHouse MCP Server is ClickHouse's official server that lets an AI assistant list databases and tables and run read-only SQL on a ClickHouse cluster, with optional chDB for querying files locally.
- **Repository:** https://github.com/ClickHouse/mcp-clickhouse
- **Install:** `claude mcp add clickhouse -e 'CLICKHOUSE_HOST=<clickhouse-host>' -e CLICKHOUSE_PORT=8443 -e 'CLICKHOUSE_USER=<clickhouse-user>' -e 'CLICKHOUSE_PASSWORD=<clickhouse-password>' -e CLICKHOUSE_SECURE=true -e CLICKHOUSE_VERIFY=true -e CLICKHOUSE_CONNECT_TIMEOUT=30 -- uv run --with mcp-clickhouse --python 3.12 mcp-clickhouse`
- **Transport:** stdio (local)
- **Auth:** Needs `CLICKHOUSE_HOST`, `CLICKHOUSE_USER and CLICKHOUSE_PASSWORD`
- **Tools exposed:** 3: `list_databases`, `list_tables`, `run_query`
- **Category:** Databases and data (https://mcpshelf.co/categories/databases)
- **Stats:** 898 GitHub stars, 78.5K downloads a week, last commit 27 Oct 2026, 0 upvotes on MCP Shelf
- **Install check:** Needs your setup first
- **Listed:** 2026-11-10
- **Page updated:** 2026-11-10

## Full description

### What is ClickHouse MCP Server?

**ClickHouse MCP Server is ClickHouse's official server that lets an AI assistant list databases and tables and run read-only SQL on a ClickHouse cluster, with optional chDB for querying files locally.**

ClickHouse maintains this Python server. It has a small tool set on purpose: list the databases, page through the tables in one with their columns, and run a SQL query. That is enough for an assistant to explore an unfamiliar warehouse and answer analytical questions, and it can check a query with DESCRIBE or EXPLAIN ESTIMATE before it runs something that might scan a whole table.

Queries run with readonly=1 unless you turn writes on, and even then DROP, TRUNCATE, DELETE and UPDATE need a second flag. With the optional chDB extra it also runs an embedded ClickHouse engine, so the assistant can query Parquet, CSV or a URL directly without a server.

|  |  |
| --- | --- |
| Made by | ClickHouse (ClickHouse/mcp-clickhouse) |
| GitHub | https://github.com/ClickHouse/mcp-clickhouse |
| Licence | Apache-2.0 |
| GitHub stars | 898 |
| Downloads | 78.5K a week |
| Last commit | 27 Oct 2026 |
| Tools | 3 |
| Runs on | Your computer |
| Install check | Needs your setup first |
| Category | [Databases and data](https://mcpshelf.co/categories/databases) |
| Works with | Claude Code, Cursor, Claude Desktop, VS Code, Codex, Windsurf |
| Setup checked | 10 Nov 2026 |
| Page updated | 10 Nov 2026 |

**Our check:** It needs something our Linux test machine does not have (an account, a desktop app, a Mac or a running service), so on 10 Nov 2026 we read its tools from the source code instead of running this config. The shared database listed "uvx mcp-clickhouse". The README launches the same PyPI package with uv run --with mcp-clickhouse --python 3.12, which pins a Python the package supports, so that is the config on this page.

#### Try asking ClickHouse MCP Server

- "Which tables are in the analytics database, and how big are they?"
- "What were the top 10 pages by views yesterday?"
- "Query this local Parquet file with chDB and summarise it."

#### MCP Shelf take

> ClickHouse needs something our Linux test machine does not have (an account, an app or a service), so on 10 Nov 2026 we read its source and counted 3 tools. 2 of the 3 only read; the other 1 can change things. It sits 8th of 10 in its category on our shelf by GitHub stars (898, with 78.5K downloads a week).

— MCP Shelf tests (numbers from our own runs), tested on 10 Nov 2026

### What tools does ClickHouse MCP Server have?

We listed 3 tools on 10 Nov 2026. 2 only read; the rest can change things or run commands.

| Tool | Kind | What it is for |
| --- | --- | --- |
| `list_databases` | reads | Lists every database on the cluster. |
| `list_tables` | reads | Pages through the tables in one database with their columns and CREATE statement. Takes like and not_like filters and a page size, 50 by default. |
| `run_query` | runs | Runs a SQL query and returns the rows as JSON. Read-only unless writes are turned on. Takes named {name:Type} parameters, and also answers DESCRIBE (query) and EXPLAIN ESTIMATE. |

### How do I install ClickHouse MCP Server?

#### Install steps from the ClickHouse MCP Server README

Copied from the project's [README on GitHub](https://github.com/ClickHouse/mcp-clickhouse#readme) on 10 Nov 2026 under its Apache-2.0 licence.

##### Configuration

This MCP server supports both ClickHouse and chDB. You can enable either or both depending on your needs.
Python 3.10 through 3.15 are supported. Python 3.12 is recommended for local launches.
chDB supports Python 3.10 through 3.14. On Python 3.15, the `chdb` extra skips
installing chDB through a dependency marker. Python 3.15 installs currently build
`lz4` and `PyYAML` from source, with or without the `chdb` extra. A C compiler is
required for `lz4`.

1. Open the Claude Desktop configuration file located at:
  - On macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
  - On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
2. Add the following:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "<clickhouse-port>",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_ROLE": "<clickhouse-role>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

Update the environment variables to point to your own ClickHouse service.

Or, if you'd like to try it out with the [ClickHouse SQL Playground](https://sql.clickhouse.com/), you can use the following config:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "sql-clickhouse.clickhouse.com",
        "CLICKHOUSE_PORT": "8443",
        "CLICKHOUSE_USER": "demo",
        "CLICKHOUSE_PASSWORD": "",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

For chDB (embedded ClickHouse engine), add the following configuration:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse[chdb]",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CHDB_ENABLED": "true",
        "CLICKHOUSE_ENABLED": "false",
        "CHDB_DATA_PATH": "/path/to/chdb/data"
      }
    }
  }
}
```

You can also enable both ClickHouse and chDB simultaneously:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse[chdb]",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "<clickhouse-port>",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30",
        "CHDB_ENABLED": "true",
        "CHDB_DATA_PATH": "/path/to/chdb/data"
      }
    }
  }
}
```

1. Locate the command entry for `uv` and replace it with the absolute path to the `uv` executable. This ensures that the correct version of `uv` is used when starting the server. On a mac, you can find this path using `which uv`.
2. Restart Claude Desktop to apply the changes.

###### Optional Write Access

By default, this MCP enforces read-only queries so that accidental mutations cannot happen during exploration. To allow DDL or INSERT statements, set the `CLICKHOUSE_ALLOW_WRITE_ACCESS` environment variable to `true`. The server keeps enforcing read-only mode if the ClickHouse instance itself disallows writes.

Read-only mode still permits the ClickHouse user to cancel its own queries, including queries from other connections using the same user. Use a dedicated ClickHouse user even in read-only mode. Use separate ClickHouse users for workloads that must not cancel each other's queries.

###### Destructive Operation Protection

Even when write access is enabled (`CLICKHOUSE_ALLOW_WRITE_ACCESS=true`), destructive operations require an additional opt-in flag for safety. The check covers any `DROP` statement (including the `ALTER TABLE ... DROP PARTITION` / `DROP PART` / `DROP COLUMN` clauses), any `TRUNCATE`, `DELETE` and `UPDATE` (both the lightweight statements and the `ALTER TABLE ... DELETE` / `ALTER TABLE ... UPDATE` mutations), `REPLACE TABLE`, `CREATE OR REPLACE`, `ALTER TABLE ... REPLACE PARTITION`, `ALTER TABLE ... CLEAR COLUMN` / `CLEAR INDEX` / `CLEAR PROJECTION`, and `DETACH ... PERMANENTLY`. Keywords inside string literals, quoted identifiers, SQL comments, and `{name:Type}` parameter names are ignored, so they neither trigger the check nor hide a statement from it.

This check runs in the MCP server and is a best-effort guard against accidents. It is not a security boundary. The security boundary is the ClickHouse user's grants. Read-only mode (the default) is enforced server-side via `readonly=1`. The destructive-operation gate is not server-enforced.

For write mode, give the MCP server a dedicated ClickHouse user with only the privileges it needs:

```
CREATE USER mcp_agent IDENTIFIED BY '...';
GRANT SELECT, INSERT, CREATE TABLE, ALTER ADD COLUMN ON mydb.* TO mcp_agent;
```

Data-changing operations that require privileges outside these grants fail server-side with `ACCESS_DENIED`, regardless of MCP flags. The server settings `max_table_size_to_drop` and `max_partition_size_to_drop` can also cap blast radius if pinned with settings constraints.

To enable destructive operations, set both flags:

```
"env": {
  "CLICKHOUSE_ALLOW_WRITE_ACCESS": "true",
  "CLICKHOUSE_ALLOW_DROP": "true"
}
```

This two-tier approach makes accidental deletion difficult:

- **Write operations** (INSERT, CREATE, ALTER ADD COLUMN) require `CLICKHOUSE_ALLOW_WRITE_ACCESS=true`
- **Destructive operations** (DROP, TRUNCATE, DELETE, UPDATE, and the rest of the list above) additionally require `CLICKHOUSE_ALLOW_DROP=true`

###### Running Without uv (Using System Python)

If you prefer to use the system Python installation instead of uv, you can install the package from PyPI and run it directly:

1. Install the package using pip: `python3 -m pip install mcp-clickhouse` To install chDB support as well: `python3 -m pip install 'mcp-clickhouse[chdb]'` To upgrade to the latest version: `python3 -m pip install --upgrade mcp-clickhouse`
2. Update your Claude Desktop configuration to use Python directly:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "python3",
      "args": [
        "-m",
        "mcp_clickhouse.main"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "<clickhouse-port>",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

Alternatively, you can use the installed script directly:

```
{
  "mcpServers": {
    "mcp-clickhouse": {
      "command": "mcp-clickhouse",
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "<clickhouse-port>",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

Note: Make sure to use the full path to the Python executable or the `mcp-clickhouse` script if they are not in your system PATH. You can find the paths using:

- `which python3` for the Python executable
- `which mcp-clickhouse` for the installed script

#### What you need first

- uv, which fetches the server and Python 3.12 for you
- A ClickHouse host, user and password (or the public SQL Playground to try it)

#### Claude Code

Where: Your terminal, in the project folder

```bash
claude mcp add clickhouse -e 'CLICKHOUSE_HOST=<clickhouse-host>' -e CLICKHOUSE_PORT=8443 -e 'CLICKHOUSE_USER=<clickhouse-user>' -e 'CLICKHOUSE_PASSWORD=<clickhouse-password>' -e CLICKHOUSE_SECURE=true -e CLICKHOUSE_VERIFY=true -e CLICKHOUSE_CONNECT_TIMEOUT=30 -- uv run --with mcp-clickhouse --python 3.12 mcp-clickhouse
```

#### Cursor

Where: ~/.cursor/mcp.json, or .cursor/mcp.json in a project

```json
{
  "mcpServers": {
    "clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "8443",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

#### Claude Desktop

Where: claude_desktop_config.json (Settings → Developer → Edit Config)

```json
{
  "mcpServers": {
    "clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "8443",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

This is the README's own example. Replace uv with its full path (which uv on a Mac), restart Claude Desktop, and to try it with no account use host sql-clickhouse.clickhouse.com, user demo and an empty password.

#### VS Code

Where: .vscode/mcp.json in your project

```json
{
  "servers": {
    "clickhouse": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "8443",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

#### Codex

Where: ~/.codex/config.toml, shared by the Codex CLI, IDE extension and ChatGPT desktop app

```
[mcp_servers.clickhouse]
command = "uv"
args = ["run", "--with", "mcp-clickhouse", "--python", "3.12", "mcp-clickhouse"]

[mcp_servers.clickhouse.env]
CLICKHOUSE_HOST = "<clickhouse-host>"
CLICKHOUSE_PORT = "8443"
CLICKHOUSE_USER = "<clickhouse-user>"
CLICKHOUSE_PASSWORD = "<clickhouse-password>"
CLICKHOUSE_SECURE = "true"
CLICKHOUSE_VERIFY = "true"
CLICKHOUSE_CONNECT_TIMEOUT = "30"
```

Or run: `codex mcp add clickhouse --env 'CLICKHOUSE_HOST=<clickhouse-host>' --env CLICKHOUSE_PORT=8443 --env 'CLICKHOUSE_USER=<clickhouse-user>' --env 'CLICKHOUSE_PASSWORD=<clickhouse-password>' --env CLICKHOUSE_SECURE=true --env CLICKHOUSE_VERIFY=true --env CLICKHOUSE_CONNECT_TIMEOUT=30 -- uv run --with mcp-clickhouse --python 3.12 mcp-clickhouse`

#### Windsurf

Where: ~/.codeium/windsurf/mcp_config.json

```json
{
  "mcpServers": {
    "clickhouse": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp-clickhouse",
        "--python",
        "3.12",
        "mcp-clickhouse"
      ],
      "env": {
        "CLICKHOUSE_HOST": "<clickhouse-host>",
        "CLICKHOUSE_PORT": "8443",
        "CLICKHOUSE_USER": "<clickhouse-user>",
        "CLICKHOUSE_PASSWORD": "<clickhouse-password>",
        "CLICKHOUSE_SECURE": "true",
        "CLICKHOUSE_VERIFY": "true",
        "CLICKHOUSE_CONNECT_TIMEOUT": "30"
      }
    }
  }
}
```

#### ChatGPT

Where: Not supported

ChatGPT on the web only connects to servers by URL. This one runs on your computer: the ChatGPT desktop app can start it from its MCP servers settings, with the same config as the Codex tab.

Fill in your own service. To try it with no account, use CLICKHOUSE_HOST sql-clickhouse.clickhouse.com, user demo and an empty password. In Claude Desktop, give the full path to uv (which uv shows it).

Checked against the project's own install docs on 10 Nov 2026: https://github.com/ClickHouse/mcp-clickhouse#readme, https://pypi.org/project/mcp-clickhouse/

### How do I configure ClickHouse MCP Server?

| Setting | Kind | Required | What it does |
| --- | --- | --- | --- |
| `CLICKHOUSE_HOST` | env | yes | The ClickHouse server's hostname: the database endpoint, not where the MCP server listens. Example: `abc123.eu-west-1.aws.clickhouse.cloud` |
| `CLICKHOUSE_USER and CLICKHOUSE_PASSWORD` | env | yes | The database login. Use a dedicated user with only the grants it needs, never the default or an admin user. The password can be left out when a client certificate signs you in. |
| `CLICKHOUSE_PORT` | env | no | The HTTP interface port: 8443 with TLS, 8123 without. The native ports 9000 and 9440 do not work with this server. Example: `8443` |
| `CLICKHOUSE_SECURE` | env | no | HTTPS to the database. On by default; set false only for a plain-HTTP local server on 8123. Example: `true` |
| `CLICKHOUSE_DATABASE` | env | no | The database queries use when they do not name one. Example: `analytics` |
| `CLICKHOUSE_ROLE` | env | no | A ClickHouse role to use, for users whose grants come through a role. |
| `CLICKHOUSE_ALLOW_WRITE_ACCESS` | env | no | Allows CREATE, INSERT and ALTER ADD COLUMN. Off by default, when every query runs with readonly=1. Example: `true` |
| `CLICKHOUSE_ALLOW_DROP` | env | no | Also allows DROP, TRUNCATE, DELETE, UPDATE and the other destructive statements. Only works alongside write access, and is a guard against accidents rather than a security boundary. Example: `true` |
| `CLICKHOUSE_MCP_QUERY_TIMEOUT` | env | no | Seconds a query may run before the server gives up and sends KILL QUERY. Default 30. Example: `120` |
| `CHDB_ENABLED and CHDB_DATA_PATH` | env | no | Turn on the chDB tool and say where its data lives (in memory by default). Needs mcp-clickhouse[chdb] in the uv command. Set CLICKHOUSE_ENABLED=false for chDB alone. |
| `CLICKHOUSE_MCP_SERVER_TRANSPORT` | env | no | stdio by default, or http to serve over the network on 127.0.0.1:8000, where a bearer token or OAuth is required unless you turn authentication off. Example: `stdio` |

### What can ClickHouse MCP Server read and change?

**It can read**

- Database and table names, columns and CREATE statements
- Any rows the ClickHouse user can SELECT
- Local files and URLs, through chDB when it is on

**It can change**

- Nothing by default: queries run with readonly=1
- Tables and data, only with CLICKHOUSE_ALLOW_WRITE_ACCESS (and CLICKHOUSE_ALLOW_DROP for deletes and drops)

**Safer setup:** Leave both write flags off and connect as a user with SELECT only on the databases you want explored. Read-only mode still lets that user cancel its own queries, so give the server its own user.

### Good for

- Asking analytical questions of event or log tables in plain English
- Exploring the schema of a ClickHouse Cloud service you have just been given
- Querying local Parquet or CSV files through chDB without loading them anywhere

### ClickHouse MCP Server not working? Common fixes

**Port 9000 is for clickhouse-client program**
You pointed it at the native protocol port. Use the HTTP port instead: 8443 with TLS or 8123 without.

**Confusing HTTP or SSL errors when connecting**
CLICKHOUSE_SECURE and the port probably disagree, such as false with 8443. Keep true for ClickHouse Cloud and any HTTPS endpoint.

**Claude Desktop cannot find uv**
Desktop apps do not always see your shell PATH. Put the full path from which uv in the command field.

**Query timed out after 30 seconds**
Raise CLICKHOUSE_MCP_QUERY_TIMEOUT, or ask the assistant to run EXPLAIN ESTIMATE first and narrow the query.

**An INSERT or CREATE fails with a readonly error**
That is the default read-only mode. Set CLICKHOUSE_ALLOW_WRITE_ACCESS to true if you really want writes, and check the user's grants allow them.

### What are the alternatives to ClickHouse MCP Server?

| Server | What it does | Tools | Runs on | Licence | Stars |
| --- | --- | --- | --- | --- | --- |
| [ClickHouse MCP Server](https://mcpshelf.co/servers/clickhouse) | ClickHouse's own server: read-only SQL on your cluster, plus chDB for local files. | 3 | Your computer | Apache-2.0 | 898 |
| [Neon MCP Server](https://mcpshelf.co/servers/neon) | Neon Postgres from chat: projects, branches, SQL and migrations tested on a branch. | 65 | Hosted | MIT | 658 |
| [Redis MCP Server](https://mcpshelf.co/servers/redis) | Redis's own server: keys, hashes, streams, JSON and vector search in plain English. | 53 | Your computer | MIT | 641 |
| [Postgres MCP Pro](https://mcpshelf.co/servers/postgres-mcp-pro) | SQL, query plans, health checks and index advice for Postgres. | 9 | Your computer | MIT | 3.4K |
| [Supabase](https://mcpshelf.co/servers/supabase) | Manage Supabase projects, tables, migrations, logs and Edge Functions. | 29 | Hosted | Apache-2.0 | 3K |
| [MCP Toolbox for Databases](https://mcpshelf.co/servers/mcp-toolbox-for-databases) | Google's toolbox for Postgres, MySQL, BigQuery, Spanner and other databases. | 29 | Your computer | Apache-2.0 | 16.7K |

### ClickHouse MCP Server FAQ

#### Is the ClickHouse MCP Server official?

Yes. ClickHouse, Inc. maintains it in the ClickHouse organisation on GitHub and publishes it on PyPI as mcp-clickhouse, under the Apache-2.0 licence.

#### Can I try the ClickHouse MCP Server without an account?

Yes. Point it at the public ClickHouse SQL Playground: CLICKHOUSE_HOST sql-clickhouse.clickhouse.com, port 8443, user demo and an empty password. It has sample datasets to ask questions about.

#### Can the assistant change or delete my data?

Not by default. Every query runs with readonly=1. CLICKHOUSE_ALLOW_WRITE_ACCESS allows inserts and table creation, and destructive statements also need CLICKHOUSE_ALLOW_DROP. The user's own grants are the real limit.

#### Does it work with ClickHouse Cloud?

Yes. Use your service's hostname, port 8443 and CLICKHOUSE_SECURE true, with a database user made for the server. A self-hosted ClickHouse works the same way over its HTTP interface.

#### What is chDB and do I need it?

chDB is ClickHouse running inside the server process, with no database to connect to. Turn it on with the chdb extra and CHDB_ENABLED when you want the assistant to query Parquet, CSV or JSON files and URLs directly.

#### Why does the config use uv run instead of uvx?

The README launches it with uv run --with mcp-clickhouse --python 3.12, which pins a Python version the package supports. It is the same PyPI package uvx would fetch.

#### Can I host it for a team over HTTP?

Yes. Set CLICKHOUSE_MCP_SERVER_TRANSPORT to http. It then requires a bearer token in CLICKHOUSE_MCP_AUTH_TOKEN, or OAuth through FastMCP, and answers health checks at /health.

#### What does it cost?

The server is free and open source. You pay only for the ClickHouse service you connect it to, and the SQL Playground is free to use.

#### How do I add ClickHouse MCP Server to Cursor?

In ~/.cursor/mcp.json, or .cursor/mcp.json for one project, add an entry named clickhouse that runs uv run --with mcp-clickhouse --python 3.12 mcp-clickhouse, with CLICKHOUSE_HOST, CLICKHOUSE_PORT, CLICKHOUSE_USER, CLICKHOUSE_PASSWORD, CLICKHOUSE_SECURE, CLICKHOUSE_VERIFY and CLICKHOUSE_CONNECT_TIMEOUT set under env. Save, and the tools show up in Agent chat.

#### Can I use ClickHouse MCP Server in VS Code?

Yes, through GitHub Copilot. In .vscode/mcp.json, add a server named clickhouse with type stdio that runs uv run --with mcp-clickhouse --python 3.12 mcp-clickhouse, with CLICKHOUSE_HOST, CLICKHOUSE_PORT, CLICKHOUSE_USER, CLICKHOUSE_PASSWORD, CLICKHOUSE_SECURE, CLICKHOUSE_VERIFY and CLICKHOUSE_CONNECT_TIMEOUT set under env. Then switch Copilot Chat to Agent mode to use its tools.

#### Does ClickHouse MCP Server work with Codex?

Yes. Add an [mcp_servers.clickhouse] table to ~/.codex/config.toml with the command and args from the Codex tab, and CLICKHOUSE_HOST, CLICKHOUSE_PORT, CLICKHOUSE_USER, CLICKHOUSE_PASSWORD, CLICKHOUSE_SECURE, CLICKHOUSE_VERIFY and CLICKHOUSE_CONNECT_TIMEOUT in its env table. The Codex CLI and IDE extension share that file.

Full docs on GitHub: https://github.com/ClickHouse/mcp-clickhouse

## Notes for agents

Fetch these instead of parsing the HTML page:

- llms.txt: https://mcpshelf.co/llms.txt
- llms-full.txt: https://mcpshelf.co/llms-full.txt
- ai.txt: https://mcpshelf.co/ai.txt
- Full catalog (.md): https://mcpshelf.co/catalog.md
- API spec: https://mcpshelf.co/openapi.json
- MCP server: https://mcpshelf.co/mcp
- MCP manifest: https://mcpshelf.co/.well-known/mcp.json
- Developer docs: https://mcpshelf.co/developers

MCP endpoint (Streamable HTTP, no key): https://mcpshelf.co/mcp. REST API: https://mcpshelf.co/api/v1.

