Skip to main content
Glama
OliveriGuido

Databricks MCP Server

by OliveriGuido

Databricks MCP Server — Natural-Language Analytics POC

A small Model Context Protocol server that lets an LLM client (e.g. Claude Desktop) answer business questions in natural language over a Databricks dataset — without writing SQL by hand.

It runs against the public samples.nyctaxi.trips dataset that ships with every Databricks workspace, so it's reproducible by anyone.

What it exposes (the three MCP primitives)

Primitive

Name

Purpose

Tool

run_query

Executes a read-only SQL query against samples.nyctaxi.trips and returns the rows.

Resource

schema://nyctaxi

Curated schema + metric definitions and gotchas — the context layer that makes the generated SQL correct.

Prompts

revenue_by_month, busiest_pickup_zones, trips_by_hour, fare_distance_summary

Ready-made business questions.

Related MCP server: MCP Iceberg Catalog

Safety / governance

Two layers, on purpose:

  1. App-level guard (is_read_only): only a single SELECT/WITH statement is accepted; any write/DDL keyword (INSERT, UPDATE, DROP, ...) is rejected, and a LIMIT 1000 is appended when missing.

  2. The real guarantee: connect with a Databricks token whose grants are read-only on the catalog. App guards reduce footguns; permissions are what actually protect the data. Never give an LLM a write-capable credential.

Architecture

Claude Desktop  ──stdio──►  MCP server (this repo)  ──Databricks SQL connector──►  samples.nyctaxi.trips
   (client)                  tool · resource · prompts                              (read-only)

run_query doesn't open the connection in-process — it shells out to query_runner.py (subprocess.run(..., stdin=subprocess.DEVNULL, capture_output=True)). See the note below for why.

Implementation note: why run_query uses a subprocess

Both points were reproduced and verified on Windows + the FastMCP stdio transport (Claude Desktop and the MCP Inspector). Symptom in both: the tool call hangs and the client returns MCP error -32001: Request timed out at ~60s, even though the same query runs in ~4s with the connector directly.

  1. sql.connect() stalls ~60s when called inside the server process. From a clean child process it connects in ~2s; inside the FastMCP process it blocks until the client's request times out. It stalls on the event-loop thread and on a worker thread, so it's a process-level interaction with the connector — not just the event loop being blocked. Running the query in a child process avoids it. (Disabling telemetry / use_cloud_fetch does not help.)

  2. stdin=subprocess.DEVNULL is required on the child. A stdio MCP server's own stdin is the JSON-RPC pipe from the client. A child started with the default stdin=None inherits that pipe handle and hangs until the client gives up (~60s). Detaching stdin makes it return at query speed. capture_output=True already detaches stdout/stderr — stdin is the one that's easy to miss, so piping the query out to a subprocess without it does not fix the hang.

Gotcha — don't launch the Inspector from Git Bash on Windows. MSYS2 rewrites the POSIX-looking DATABRICKS_HTTP_PATH (/sql/1.0/warehouses/…C:/Program Files/Git/sql/1.0/warehouses/…), so the server gets a 404, not a timeout. Use PowerShell or cmd. Claude Desktop passes env vars directly and is unaffected.

Run it

Prereqs: Python 3.11+, uv, a Databricks workspace with a running SQL Warehouse and the samples catalog.

Windows / PowerShell (recommended on Windows — see the Git Bash gotcha above):

cd "C:\path\to\databricks-mcp"
uv sync                                    # first time only

# from SQL Warehouses -> Connection details, plus a personal access token.
# These live only in THIS PowerShell window (nothing is written to disk):
$env:DATABRICKS_HOST      = "dbc-xxxxxxxx-xxxx.cloud.databricks.com"
$env:DATABRICKS_HTTP_PATH = "/sql/1.0/warehouses/xxxxxxxxxxxxxxxx"
$env:DATABRICKS_TOKEN     = "dapixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# launch the browser inspector, then run a query from its UI:
npx @modelcontextprotocol/inspector uv run server.py
uv sync
export DATABRICKS_HOST="adb-....azuredatabricks.net"
export DATABRICKS_HTTP_PATH="/sql/1.0/warehouses/...."
export DATABRICKS_TOKEN="dapi...."
npx @modelcontextprotocol/inspector uv run server.py

Connect to Claude Desktop

You can reach the config file in two ways:

  • Via the UI (recommended): in Claude Desktop go to Settings → Developer → Edit Config. This opens (and creates, if missing) claude_desktop_config.json in the right folder.

  • By path: edit it directly at %APPDATA%\Claude\claude_desktop_config.json (Windows) or ~/Library/Application Support/Claude/claude_desktop_config.json (macOS).

Copy the contents of claude_desktop_config.example.json into that file, fill in your real values, and restart Claude Desktop. Then ask things like:

"What were the busiest pickup zones, and how does monthly revenue trend?"

Notes

  • samples.nyctaxi.trips is a public Databricks dataset; no private data is used.

  • Secrets live in env vars / the Claude Desktop config, both git-ignored.

Available Tools

1 tool
run_queryA

Run a READ-ONLY SQL query against samples.nyctaxi.trips and return rows. Only a single SELECT/WITH is allowed; LIMIT 1000 is appended if missing.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Given no annotations, the description reveals read-only behavior, query type restrictions, and automatic LIMIT. It does not cover error handling or response format, but core behaviors are disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences: first states purpose, second adds constraints. No superfluous words, front-loaded structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With low complexity (1 param) and an output schema present, the description covers essential context: target table, read-only, and query limitations. Minor gaps like error handling are acceptable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so description must compensate. It adds context by specifying the target table and query constraints, which adds meaning beyond the bare parameter name.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Run a READ-ONLY SQL query' and the specific resource 'samples.nyctaxi.trips', with explicit read-only nature and allowed query types. This fully defines the tool's purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides constraints like 'Only a single SELECT/WITH is allowed' and 'LIMIT 1000 is appended if missing', guiding usage. No alternatives are discussed, but no siblings exist, so it's adequate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

A4/5.0
Disambiguation5/5

With only one tool, there is no risk of confusion between tools. The tool's purpose is clearly defined as running a read-only SQL query on a specific table.

Naming Consistency5/5

With a single tool, naming consistency is not a concern. The tool name 'run_query' follows a common verb_noun pattern.

Tool Count1/5

The server is named 'Databricks MCP Server', implying access to a wide range of Databricks functionality, but only one tool for a single query on a fixed table is provided. This is an extreme mismatch in scope.

Completeness1/5

The tool set is severely incomplete for a Databricks server. It lacks operations for managing databases, tables, clusters, or running arbitrary SQL beyond the fixed sample table.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • F
    license
    B
    quality
    D
    maintenance
    A Model Context Protocol server that provides a SQL interface for querying and managing Apache Iceberg tables through Claude desktop, allowing natural language interaction with Iceberg data lakes.
    1
    8
  • A
    license
    Not graded
    quality
    C
    maintenance
    A Model Context Protocol server that enables AI assistants to interact with Databricks workspaces, allowing them to browse Unity Catalog, query metadata, sample data, and execute SQL queries.
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/OliveriGuido/databricks-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server