databricks-mcp-toolkit 0.2.0__py3-none-any.whl

databricks_mcp/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""MCP server for Databricks."""
+
+__version__ = "0.2.0"
+
+__all__ = ["__version__"]

databricks_mcp/__main__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+import sys
+
+from databricks_mcp.cli import main
+
+sys.exit(main())

databricks_mcp/api/__init__.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Thin wrappers over Databricks REST endpoints. Each function takes a DatabricksClient."""
+
+from databricks_mcp.api import (
+    clusters,
+    command_execution,
+    dbfs,
+    files,
+    jobs,
+    sql,
+    unity_catalog,
+    warehouses,
+    workspace,
+)
+
+__all__ = [
+    "clusters",
+    "command_execution",
+    "dbfs",
+    "files",
+    "jobs",
+    "sql",
+    "unity_catalog",
+    "warehouses",
+    "workspace",
+]

databricks_mcp/api/clusters.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Clusters API 2.1."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/2.1/clusters"
+
+
+async def list_clusters(
+    client: DatabricksClient,
+    page_size: int | None = None,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    return await client.get(f"{BASE}/list", {"page_size": page_size, "page_token": page_token})
+
+
+async def get_cluster(client: DatabricksClient, cluster_id: str) -> dict[str, Any]:
+    return await client.get(f"{BASE}/get", {"cluster_id": cluster_id})
+
+
+async def create_cluster(client: DatabricksClient, spec: dict[str, Any]) -> dict[str, Any]:
+    return await client.post(f"{BASE}/create", spec)
+
+
+async def start_cluster(client: DatabricksClient, cluster_id: str) -> dict[str, Any]:
+    return await client.post(f"{BASE}/start", {"cluster_id": cluster_id})
+
+
+async def restart_cluster(client: DatabricksClient, cluster_id: str) -> dict[str, Any]:
+    return await client.post(f"{BASE}/restart", {"cluster_id": cluster_id})
+
+
+async def resize_cluster(
+    client: DatabricksClient,
+    cluster_id: str,
+    num_workers: int | None = None,
+    autoscale_min_workers: int | None = None,
+    autoscale_max_workers: int | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"cluster_id": cluster_id}
+    if autoscale_min_workers is not None or autoscale_max_workers is not None:
+        if autoscale_min_workers is None or autoscale_max_workers is None:
+            raise ValueError("Set both autoscale_min_workers and autoscale_max_workers.")
+        body["autoscale"] = {
+            "min_workers": autoscale_min_workers,
+            "max_workers": autoscale_max_workers,
+        }
+    elif num_workers is not None:
+        body["num_workers"] = num_workers
+    else:
+        raise ValueError("Pass num_workers, or both autoscale_min_workers and autoscale_max_workers.")
+    return await client.post(f"{BASE}/resize", body)
+
+
+async def terminate_cluster(client: DatabricksClient, cluster_id: str) -> dict[str, Any]:
+    # "delete" in the API terminates; the config is kept and the cluster can be restarted.
+    return await client.post(f"{BASE}/delete", {"cluster_id": cluster_id})
+
+
+async def list_spark_versions(client: DatabricksClient) -> dict[str, Any]:
+    return await client.get(f"{BASE}/spark-versions")
+
+
+async def list_node_types(client: DatabricksClient) -> dict[str, Any]:
+    return await client.get(f"{BASE}/list-node-types")

databricks_mcp/api/command_execution.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Command Execution API 1.2. Still the current (and only) version for running code
+on an all-purpose cluster with state kept between commands."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/1.2"
+_RUNNING = {"Queued", "Running", "Cancelling"}
+
+
+async def create_context(client: DatabricksClient, cluster_id: str, language: str) -> dict[str, Any]:
+    return await client.post(f"{BASE}/contexts/create", {"clusterId": cluster_id, "language": language})
+
+
+async def context_status(client: DatabricksClient, cluster_id: str, context_id: str) -> dict[str, Any]:
+    return await client.get(f"{BASE}/contexts/status", {"clusterId": cluster_id, "contextId": context_id})
+
+
+async def destroy_context(client: DatabricksClient, cluster_id: str, context_id: str) -> dict[str, Any]:
+    return await client.post(f"{BASE}/contexts/destroy", {"clusterId": cluster_id, "contextId": context_id})
+
+
+async def execute(
+    client: DatabricksClient, cluster_id: str, context_id: str, command: str, language: str
+) -> dict[str, Any]:
+    return await client.post(
+        f"{BASE}/commands/execute",
+        {"clusterId": cluster_id, "contextId": context_id, "command": command, "language": language},
+    )
+
+
+async def command_status(client: DatabricksClient, cluster_id: str, context_id: str, command_id: str) -> dict[str, Any]:
+    return await client.get(
+        f"{BASE}/commands/status",
+        {"clusterId": cluster_id, "contextId": context_id, "commandId": command_id},
+    )
+
+
+async def cancel(client: DatabricksClient, cluster_id: str, context_id: str, command_id: str) -> dict[str, Any]:
+    return await client.post(
+        f"{BASE}/commands/cancel",
+        {"clusterId": cluster_id, "contextId": context_id, "commandId": command_id},
+    )
+
+
+async def wait_for_command(
+    client: DatabricksClient,
+    cluster_id: str,
+    context_id: str,
+    command_id: str,
+    timeout_seconds: float = 120,
+    poll_interval_seconds: float = 1,
+) -> dict[str, Any]:
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        status = await command_status(client, cluster_id, context_id, command_id)
+        if status.get("status") not in _RUNNING or time.monotonic() >= deadline:
+            return status
+        await asyncio.sleep(poll_interval_seconds)
+
+
+async def run_once(
+    client: DatabricksClient,
+    cluster_id: str,
+    command: str,
+    language: str,
+    timeout_seconds: float = 120,
+    poll_interval_seconds: float = 1,
+) -> dict[str, Any]:
+    """Create a context, run one command, wait, and always clean the context up."""
+    context = await create_context(client, cluster_id, language)
+    context_id = context["id"]
+    try:
+        started = await execute(client, cluster_id, context_id, command, language)
+        return await wait_for_command(
+            client, cluster_id, context_id, started["id"], timeout_seconds, poll_interval_seconds
+        )
+    finally:
+        try:
+            await destroy_context(client, cluster_id, context_id)
+        except Exception:  # cleanup failure shouldn't hide the command's result
+            pass

databricks_mcp/api/dbfs.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""DBFS API 2.0. Legacy: Databricks recommends Unity Catalog volumes (see files.py).
+I only keep read access here for workspaces that still have data in DBFS."""
+
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/2.0/dbfs"
+_MAX_READ = 1_048_576  # the API's own per-call ceiling
+
+
+async def list_files(client: DatabricksClient, path: str) -> dict[str, Any]:
+    return await client.get(f"{BASE}/list", {"path": path})
+
+
+async def read_file(client: DatabricksClient, path: str, max_bytes: int = 100_000) -> dict[str, Any]:
+    length = max(1, min(max_bytes, _MAX_READ))
+    result = await client.get(f"{BASE}/read", {"path": path, "offset": 0, "length": length})
+    raw = base64.b64decode(result.get("data") or "")
+    out: dict[str, Any] = {"path": path, "bytes_read": result.get("bytes_read", len(raw))}
+    try:
+        out["content"] = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        out["content"] = None
+        out["note"] = "Binary file; content not shown."
+    status = await client.get(f"{BASE}/get-status", {"path": path})
+    out["total_bytes"] = status.get("file_size")
+    out["truncated"] = (status.get("file_size") or 0) > len(raw)
+    return out

databricks_mcp/api/files.py

@@ -0,0 +1,94 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Files API 2.0 for Unity Catalog volumes (/Volumes/<catalog>/<schema>/<volume>/...).
+
+This is what Databricks recommends over DBFS now. Files API 3.0 exists but is still in
+beta, needs an admin toggle and a regional hostname, so I'm staying on 2.0.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/2.0/fs"
+
+
+def _path(path: str) -> str:
+    if not path.startswith("/Volumes/"):
+        raise ValueError("Files API paths must be absolute volume paths, e.g. /Volumes/main/default/my_vol/a.csv")
+    return quote(path, safe="/")
+
+
+async def list_directory(
+    client: DatabricksClient,
+    path: str,
+    page_size: int | None = None,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    directory = _path(path.rstrip("/") + "/")
+    return await client.get(f"{BASE}/directories{directory}", {"page_size": page_size, "page_token": page_token})
+
+
+async def read_file(client: DatabricksClient, path: str, max_bytes: int = 100_000) -> dict[str, Any]:
+    # Range keeps me from pulling a 5 GB file into memory just to show the first page.
+    response = await client.request(
+        "GET",
+        f"{BASE}/files{_path(path)}",
+        headers={"Range": f"bytes=0-{max_bytes - 1}"},
+        raw=True,
+    )
+    data = response.content[:max_bytes]
+    total = _total_size(response) or len(data)
+    result: dict[str, Any] = {
+        "path": path,
+        "content_type": response.headers.get("content-type"),
+        "bytes_returned": len(data),
+        "total_bytes": total,
+        "truncated": total > len(data),
+    }
+    try:
+        result["content"] = data.decode("utf-8")
+    except UnicodeDecodeError:
+        result["content"] = None
+        result["note"] = "Binary file; content not shown."
+    return result
+
+
+def _total_size(response: Any) -> int | None:
+    content_range = response.headers.get("content-range")  # "bytes 0-99/12345"
+    if content_range and "/" in content_range:
+        tail = content_range.rsplit("/", 1)[1]
+        if tail.isdigit():
+            return int(tail)
+    length = response.headers.get("content-length")
+    if length and length.isdigit() and response.status_code == 200:
+        return int(length)
+    return None
+
+
+async def write_file(client: DatabricksClient, path: str, content: str, overwrite: bool = False) -> dict[str, Any]:
+    await client.request(
+        "PUT",
+        f"{BASE}/files{_path(path)}",
+        params={"overwrite": "true" if overwrite else "false"},
+        content=content.encode("utf-8"),
+        headers={"Content-Type": "application/octet-stream"},
+        raw=True,
+    )
+    return {"path": path, "written_bytes": len(content.encode("utf-8"))}
+
+
+async def delete_file(client: DatabricksClient, path: str) -> dict[str, Any]:
+    await client.request("DELETE", f"{BASE}/files{_path(path)}", raw=True)
+    return {"path": path, "deleted": True}
+
+
+async def create_directory(client: DatabricksClient, path: str) -> dict[str, Any]:
+    await client.request("PUT", f"{BASE}/directories{_path(path.rstrip('/') + '/')}", raw=True)
+    return {"path": path, "created": True}

databricks_mcp/api/jobs.py

@@ -0,0 +1,144 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Jobs API 2.2 (current). 2.2 pages tasks/job_clusters past 100 entries and queues jobs by default."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from databricks_mcp.client import DatabricksAPIError, DatabricksClient
+
+BASE = "/api/2.2/jobs"
+_TERMINAL_LIFE_CYCLE = {"TERMINATED", "SKIPPED", "INTERNAL_ERROR"}
+_MAX_TASK_OUTPUTS = 20
+
+
+async def list_jobs(
+    client: DatabricksClient,
+    name: str | None = None,
+    limit: int = 25,
+    page_token: str | None = None,
+    expand_tasks: bool = False,
+) -> dict[str, Any]:
+    return await client.get(
+        f"{BASE}/list",
+        {
+            "name": name,
+            "limit": max(1, min(limit, 100)),
+            "page_token": page_token,
+            "expand_tasks": expand_tasks or None,
+        },
+    )
+
+
+async def get_job(client: DatabricksClient, job_id: int, page_token: str | None = None) -> dict[str, Any]:
+    return await client.get(f"{BASE}/get", {"job_id": job_id, "page_token": page_token})
+
+
+async def run_job(
+    client: DatabricksClient,
+    job_id: int,
+    job_parameters: dict[str, str] | None = None,
+    notebook_params: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"job_id": job_id}
+    if job_parameters:
+        body["job_parameters"] = job_parameters
+    if notebook_params:
+        body["notebook_params"] = notebook_params
+    return await client.post(f"{BASE}/run-now", body)
+
+
+async def submit_run(client: DatabricksClient, run_spec: dict[str, Any]) -> dict[str, Any]:
+    if not run_spec.get("tasks"):
+        raise ValueError("run_spec needs a non-empty 'tasks' list.")
+    return await client.post(f"{BASE}/runs/submit", run_spec)
+
+
+async def list_runs(
+    client: DatabricksClient,
+    job_id: int | None = None,
+    active_only: bool = False,
+    completed_only: bool = False,
+    limit: int = 25,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    return await client.get(
+        f"{BASE}/runs/list",
+        {
+            "job_id": job_id,
+            "active_only": active_only or None,
+            "completed_only": completed_only or None,
+            "limit": max(1, min(limit, 25)),
+            "page_token": page_token,
+        },
+    )
+
+
+async def get_run(client: DatabricksClient, run_id: int, page_token: str | None = None) -> dict[str, Any]:
+    return await client.get(f"{BASE}/runs/get", {"run_id": run_id, "page_token": page_token})
+
+
+async def cancel_run(client: DatabricksClient, run_id: int) -> dict[str, Any]:
+    return await client.post(f"{BASE}/runs/cancel", {"run_id": run_id})
+
+
+async def get_run_output(client: DatabricksClient, run_id: int) -> dict[str, Any]:
+    """runs/get-output only works on task runs, not on a multi-task parent run.
+    If I'm handed a parent run, I fetch each task's output instead."""
+    run = await get_run(client, run_id)
+    tasks = run.get("tasks") or []
+    task_runs = [t for t in tasks if t.get("run_id") and t["run_id"] != run_id]
+    if not task_runs:
+        return await client.get(f"{BASE}/runs/get-output", {"run_id": run_id})
+
+    outputs = []
+    for task in task_runs[:_MAX_TASK_OUTPUTS]:
+        task_run_id = task["run_id"]
+        try:
+            out = await client.get(f"{BASE}/runs/get-output", {"run_id": task_run_id})
+        except DatabricksAPIError as exc:
+            out = {"error": str(exc)}
+        out.pop("metadata", None)  # duplicates what get_run already returns
+        outputs.append({"task_key": task.get("task_key"), "run_id": task_run_id, **out})
+    result: dict[str, Any] = {"run_id": run_id, "state": _state(run), "tasks": outputs}
+    if len(task_runs) > _MAX_TASK_OUTPUTS:
+        result["note"] = f"Showing {_MAX_TASK_OUTPUTS} of {len(task_runs)} task outputs."
+    return result
+
+
+def _state(run: dict[str, Any]) -> dict[str, Any]:
+    return {"status": run.get("status"), "state": run.get("state")}
+
+
+def is_terminal(run: dict[str, Any]) -> bool:
+    status = (run.get("status") or {}).get("state")
+    life_cycle = (run.get("state") or {}).get("life_cycle_state")
+    return status == "TERMINATED" or life_cycle in _TERMINAL_LIFE_CYCLE
+
+
+async def wait_for_run(
+    client: DatabricksClient,
+    run_id: int,
+    poll_interval_seconds: float = 10,
+    timeout_seconds: float = 600,
+) -> dict[str, Any]:
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        run = await get_run(client, run_id)
+        if is_terminal(run):
+            return {"run_id": run_id, "finished": True, **_state(run), "run_page_url": run.get("run_page_url")}
+        if time.monotonic() >= deadline:
+            return {
+                "run_id": run_id,
+                "finished": False,
+                **_state(run),
+                "run_page_url": run.get("run_page_url"),
+                "note": f"Still running after {timeout_seconds}s. Call again to keep waiting.",
+            }
+        await asyncio.sleep(poll_interval_seconds)

databricks_mcp/api/sql.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""SQL Statement Execution API 2.0."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/2.0/sql/statements"
+_TERMINAL = {"SUCCEEDED", "FAILED", "CANCELED", "CLOSED"}
+# The API lets a request block for at most 50s; after that I poll.
+_MAX_SERVER_WAIT = 50
+
+
+async def execute(
+    client: DatabricksClient,
+    statement: str,
+    warehouse_id: str,
+    catalog: str | None = None,
+    schema: str | None = None,
+    parameters: dict[str, str] | None = None,
+    row_limit: int = 1000,
+    timeout_seconds: int = 120,
+    poll_interval_seconds: float = 2,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {
+        "statement": statement,
+        "warehouse_id": warehouse_id,
+        "disposition": "INLINE",
+        "format": "JSON_ARRAY",
+        "row_limit": row_limit,
+        "wait_timeout": f"{max(5, min(timeout_seconds, _MAX_SERVER_WAIT))}s",
+        "on_wait_timeout": "CONTINUE",
+    }
+    if catalog:
+        body["catalog"] = catalog
+    if schema:
+        body["schema"] = schema
+    if parameters:
+        body["parameters"] = [{"name": k, "value": v} for k, v in parameters.items()]
+
+    started = time.monotonic()
+    response = await client.post(BASE, body)
+    statement_id = response.get("statement_id")
+    while _state(response) not in _TERMINAL and statement_id:
+        if time.monotonic() - started >= timeout_seconds:
+            break
+        await asyncio.sleep(poll_interval_seconds)
+        response = await client.get(f"{BASE}/{statement_id}")
+    return summarize(response)
+
+
+async def get_statement(client: DatabricksClient, statement_id: str) -> dict[str, Any]:
+    return summarize(await client.get(f"{BASE}/{statement_id}"))
+
+
+async def cancel_statement(client: DatabricksClient, statement_id: str) -> dict[str, Any]:
+    await client.post(f"{BASE}/{statement_id}/cancel")
+    return {"statement_id": statement_id, "cancel_requested": True}
+
+
+def _state(response: dict[str, Any]) -> str | None:
+    return (response.get("status") or {}).get("state")
+
+
+def summarize(response: dict[str, Any]) -> dict[str, Any]:
+    """Flatten the API's manifest/result split into columns + rows the model can read."""
+    status = response.get("status") or {}
+    state = status.get("state")
+    out: dict[str, Any] = {"statement_id": response.get("statement_id"), "state": state}
+    if status.get("error"):
+        out["error"] = status["error"]
+    if state not in _TERMINAL:
+        out["note"] = "Still running. Call get_sql_statement with this statement_id to check again."
+        return out
+
+    manifest = response.get("manifest") or {}
+    columns = (manifest.get("schema") or {}).get("columns") or []
+    result = response.get("result") or {}
+    rows = result.get("data_array") or []
+    out["columns"] = [{"name": c.get("name"), "type": c.get("type_text") or c.get("type_name")} for c in columns]
+    out["rows"] = rows
+    out["row_count"] = len(rows)
+    total = manifest.get("total_row_count")
+    if total is not None:
+        out["total_row_count"] = total
+    out["truncated"] = bool(
+        manifest.get("truncated")
+        or result.get("next_chunk_index") is not None
+        or (total is not None and total > len(rows))
+    )
+    return out

databricks_mcp/api/unity_catalog.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2025-2026 Kush Patel
+# Dual-licensed: AGPL-3.0-only OR commercial license.
+# If you obtained this from GitHub or PyPI, you may use it under the AGPL-3.0 terms.
+# For commercial terms, see the project README.
+
+"""Unity Catalog API 2.1 (read-only browsing: catalogs, schemas, tables, volumes)."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from databricks_mcp.client import DatabricksClient
+
+BASE = "/api/2.1/unity-catalog"
+
+
+async def list_catalogs(
+    client: DatabricksClient, max_results: int = 100, page_token: str | None = None
+) -> dict[str, Any]:
+    return await client.get(f"{BASE}/catalogs", {"max_results": max_results, "page_token": page_token})
+
+
+async def list_schemas(
+    client: DatabricksClient,
+    catalog_name: str,
+    max_results: int = 100,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    return await client.get(
+        f"{BASE}/schemas",
+        {"catalog_name": catalog_name, "max_results": max_results, "page_token": page_token},
+    )
+
+
+async def list_tables(
+    client: DatabricksClient,
+    catalog_name: str,
+    schema_name: str,
+    max_results: int = 100,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    # omit_columns keeps the listing small; get_table has the full column list.
+    return await client.get(
+        f"{BASE}/tables",
+        {
+            "catalog_name": catalog_name,
+            "schema_name": schema_name,
+            "max_results": max_results,
+            "page_token": page_token,
+            "omit_columns": True,
+            "omit_properties": True,
+        },
+    )
+
+
+async def get_table(client: DatabricksClient, full_name: str) -> dict[str, Any]:
+    return await client.get(f"{BASE}/tables/{quote(full_name, safe='')}")
+
+
+async def list_volumes(
+    client: DatabricksClient,
+    catalog_name: str,
+    schema_name: str,
+    max_results: int = 100,
+    page_token: str | None = None,
+) -> dict[str, Any]:
+    return await client.get(
+        f"{BASE}/volumes",
+        {
+            "catalog_name": catalog_name,
+            "schema_name": schema_name,
+            "max_results": max_results,
+            "page_token": page_token,
+        },
+    )