Skip to main content
Glama
Apache Zeppelin MCP Server

Apache Zeppelin MCP Server

Apache Zeppelin MCP Server

An MCP (Model Context Protocol) server that wraps the Apache Zeppelin REST API, allowing LLM agents in Claude Desktop and Claude Code to interact with Zeppelin notebooks.

Prerequisites

  • uv installed

  • A running Apache Zeppelin instance with REST API enabled

  • Zeppelin credentials (username and password)

Related MCP server: NotebookLM MCP Server

Available Tools

Tool

Description

list_notebooks

List notebooks, with optional name_filter and limit (default 100)

search_notebooks

Full-text search across all notebook paragraphs, with max_results (default 20)

get_notebook

Get notebook overview with all paragraph code, titles, and status (no output)

list_paragraphs

List paragraph metadata (index, id, title, status) without code or output

get_paragraph

Get full content of a single paragraph (code, output, and dynamic forms)

get_paragraph_code

Get only the code/text content of a paragraph, without output or forms (saves tokens)

get_paragraph_forms

Get dynamic form definitions and current parameter values for a paragraph

update_paragraph_forms

Update dynamic form values without re-executing (preserves chart settings)

update_paragraph_config

Update paragraph visualization/chart config (graph type, column mappings, display settings)

batch_update_paragraph_config

Batch: update visualization/chart config for several paragraphs in one call

update_paragraph

Update paragraph code/text with automatic backup of previous version

batch_update_paragraph

Batch: update several paragraphs in one call (each changed paragraph is backed up)

edit_paragraph

Find-and-replace inside a paragraph's code — send only the changed snippet instead of the whole text (with automatic backup)

batch_edit_paragraph

Batch: several find-and-replace edits across one or more paragraphs in one call (all-or-nothing per paragraph, each changed paragraph is backed up once)

delete_paragraph

Delete a paragraph with automatic backup of its content

batch_delete_paragraph

Batch: delete several paragraphs in one call (each is backed up first)

move_paragraph

Move a paragraph to a new position within the same notebook

create_notebook

Create a new empty notebook

add_paragraph

Add a new paragraph to an existing notebook

batch_add_paragraph

Batch: add several paragraphs in one call, created in the given order

clone_paragraph

Clone a paragraph (code, title, and chart config) directly below the original

run_paragraph

Run a paragraph and return the result (preserves chart settings)

batch_run_paragraph

Batch: run several paragraphs sequentially in a given order, each optionally with its own dynamic-form params (stops on first error by default)

run_paragraph_async

Start paragraph execution without waiting — for parallel runs, check status with get_paragraph_status

run_all_paragraphs

Run all paragraphs in a notebook and wait for completion (preserves chart settings)

get_paragraph_status

Check execution status of a paragraph

stop_paragraph

Stop a running paragraph (cancel long-running or stuck queries)

get_notebook_permissions

Get permission information for a notebook (owners, writers, readers)

set_notebook_permissions

Set owners, writers, and readers for a notebook

export_notebook

Export notebook as JSON for backup or cross-server migration

import_notebook

Import a previously exported notebook JSON

clone_notebook

Clone an existing notebook with optional rename

Edit and delete operations automatically back up previous paragraph content to protected ~Backups notebooks before making changes.

Skills

The repo also ships two Claude Code skills that encode notebook-workflow best practices (installed automatically with the plugin setup below):

  • /notebook — create notebooks, add/edit paragraphs, configure charts and dynamic forms; finalizes every paragraph with the code editor hidden and auto-re-run disabled.

  • /review_notebook — structured notebook review: methodology, conclusions, code quality, visualization, documentation.

Ways to use this project

  1. Claude Code plugin (recommended) — one command installs the MCP server and the skills, and auto-updates on every commit. See below.

  2. Plain MCP server — register the server manually in Claude Desktop / Claude Code / any MCP client; skills are not included. See the setup sections further down.

  3. Building block for a private setup — teams can keep their own wrapper plugin (pinned URL, internal skills) in a private marketplace and launch this server from git without cloning: uvx --from git+https://github.com/german-borisevich/apache-zeppelin-mcp@<tag> apache-zeppelin-mcp

  1. Export credentials in your shell profile (the server inherits them from the environment):

export ZEPPELIN_BASE_URL="http://your-zeppelin-host:8080"
export ZEPPELIN_USERNAME="your-username"
export ZEPPELIN_PASSWORD="your-password"
  1. In Claude Code:

/plugin marketplace add german-borisevich/apache-zeppelin-mcp
/plugin install apache-zeppelin@apache-zeppelin-mcp
  1. Restart the session. The Zeppelin MCP tools and the /notebook, /review_notebook skills are now available, and the plugin auto-updates at session start whenever this repo gets new commits.

Setup for Claude Desktop

  1. Open Claude Desktop settings and navigate to the MCP servers configuration file:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

    • Windows: %APPDATA%\Claude\claude_desktop_config.json

  2. Add the Zeppelin server to the mcpServers section:

{
  "mcpServers": {
    "zeppelin": {
      "command": "uv",
      "args": [
        "--directory", "/ABSOLUTE/PATH/TO/apache-zeppelin-mcp",
        "run", "server.py"
      ],
      "env": {
        "ZEPPELIN_BASE_URL": "http://your-zeppelin-host:8080",
        "ZEPPELIN_USERNAME": "your-username",
        "ZEPPELIN_PASSWORD": "your-password"
      }
    }
  }
}

Replace /ABSOLUTE/PATH/TO/apache-zeppelin-mcp with the actual absolute path to this project directory.

  1. Restart Claude Desktop. The Zeppelin tools will appear in the tools menu (hammer icon).

Setup for Claude Code

Global (all sessions)

Run the following command to register the server for every Claude Code session:

claude mcp add zeppelin \
  -e ZEPPELIN_BASE_URL=http://your-zeppelin-host:8080 \
  -e ZEPPELIN_USERNAME=your-username \
  -e ZEPPELIN_PASSWORD=your-password \
  -- uv --directory /ABSOLUTE/PATH/TO/apache-zeppelin-mcp run server.py

Replace the URL, credentials, and path with your actual values.

To verify it was added:

claude mcp list

To remove it later:

claude mcp remove zeppelin

Project-scoped (single project only)

To make the server available only when Claude Code is running inside a specific project, add a .mcp.json file to the project root:

{
  "mcpServers": {
    "zeppelin": {
      "command": "uv",
      "args": [
        "--directory", "/ABSOLUTE/PATH/TO/apache-zeppelin-mcp",
        "run", "server.py"
      ],
      "env": {
        "ZEPPELIN_BASE_URL": "http://your-zeppelin-host:8080",
        "ZEPPELIN_USERNAME": "your-username",
        "ZEPPELIN_PASSWORD": "your-password"
      }
    }
  }
}

Replace the URL, credentials, and path with your actual values.

The server will only be loaded when Claude Code is started from that project directory (or a subdirectory). Other projects and global sessions will not see the Zeppelin tools.

Tip: If .mcp.json contains credentials you don't want to commit, add it to your .gitignore.

Verifying the Connection

1. Check that the server starts

Run the server directly to confirm it starts without errors:

ZEPPELIN_BASE_URL=http://your-zeppelin-host:8080 \
ZEPPELIN_USERNAME=your-username \
ZEPPELIN_PASSWORD=your-password \
uv run server.py

If configuration is correct the server will authenticate with Zeppelin and then wait for input on stdin (this is normal — it communicates via the MCP stdio protocol). Press Ctrl+C to stop.

If environment variables are missing you will see a ValueError immediately. If credentials are wrong, you will see an authentication error at startup.

2. Test tools with MCP Inspector

The MCP Inspector provides a web UI for testing each tool interactively:

ZEPPELIN_BASE_URL=http://your-zeppelin-host:8080 \
ZEPPELIN_USERNAME=your-username \
ZEPPELIN_PASSWORD=your-password \
mcp dev server.py

This opens a browser where you can:

  • See all 30 registered tools

  • Call list_notebooks to verify the connection to Zeppelin is working

  • Test search_notebooks with a keyword

  • Try get_notebook with a notebook ID from the list

  • Create a test notebook, add a paragraph, run it, and check the result

3. Test from Claude Desktop

After adding the server to claude_desktop_config.json and restarting Claude Desktop:

  1. Open a new conversation

  2. Click the hammer icon at the bottom of the input box — you should see all 30 Zeppelin tools listed

  3. Ask Claude: "List all my Zeppelin notebooks"

  4. Claude will call list_notebooks and show the results

If the tools don't appear, check the Claude Desktop logs:

  • macOS: ~/Library/Logs/Claude/mcp*.log

  • Windows: %APPDATA%\Claude\Logs\mcp*.log

4. Test from Claude Code

After adding the server with claude mcp add:

  1. Start Claude Code: claude

  2. Ask: "List all my Zeppelin notebooks"

  3. Claude will call list_notebooks — approve the tool call when prompted

5. End-to-end smoke test

Ask the agent to run through this sequence to fully verify all tools:

1. List all notebooks
2. Search for "select" (or any keyword likely in your notebooks)
3. Get the details of one notebook from the list
4. Create a new notebook called "MCP Test"
5. Add a paragraph with: %md Hello from MCP!
6. Run that paragraph
7. Check the paragraph status

If all steps succeed, the server is fully operational.

Automatic Backup

When update_paragraph/batch_update_paragraph, edit_paragraph/batch_edit_paragraph, or delete_paragraph/batch_delete_paragraph modifies existing content, the previous version is automatically saved to a backup notebook before the change is applied.

  • Backup location: Users/<username>/~Backups/<original_notebook_path>/<notebook_name>_<notebook_id>_backup (mirrors the original path)

  • What triggers a backup: update_paragraph/batch_update_paragraph and edit_paragraph/batch_edit_paragraph (per paragraph, only when text actually changes), delete_paragraph/batch_delete_paragraph (always, per paragraph)

  • What doesn't trigger a backup: move_paragraph, title-only changes, add_paragraph

  • Protection: All mutating tools (add, run, update, delete, move, set permissions) are blocked from operating on ~Backups notebooks. Read-only tools work normally on backup notebooks.

  • Backup paragraph titles include a UTC timestamp and operation label, e.g. [2025-01-15 14:30 UTC | EDIT] paragraph_20250115-143012_123456

If backup creation fails, the destructive operation is aborted — no data is lost.

Troubleshooting

Problem

Cause

Fix

Tool error ZEPPELIN_… not set

Missing env vars

Set all three env vars (ZEPPELIN_BASE_URL, ZEPPELIN_USERNAME, ZEPPELIN_PASSWORD), then reconnect the server (/mcp in Claude Code) or restart the client

httpx.ConnectError

Zeppelin is unreachable

Verify ZEPPELIN_BASE_URL is correct and Zeppelin is running

Tool error Zeppelin rejected the login …

Wrong credentials

Check ZEPPELIN_USERNAME and ZEPPELIN_PASSWORD, then reconnect the server or restart the client

Tools don't appear in Claude Desktop

Config error or server crash

Check the MCP log files and verify claude_desktop_config.json syntax

Tools don't appear in Claude Code

Server not registered

Run claude mcp list and re-add if missing

Note: The server starts even when credentials are missing or wrong, and logs in on the first tool call — configuration problems show up as tool errors rather than a server that fails to connect. Env vars are read once at startup, so after changing them the server must be restarted.

The server also automatically re-authenticates when sessions expire (including HTTP 302 redirects to the login page). You should not need to manually restart the server due to session timeouts.

Available Tools

33 tools
add_paragraphB

Add a new paragraph to an existing notebook.

Args:
    notebook_id: The notebook ID to add the paragraph to
    text: The code/content for the paragraph
    title: Optional title for the paragraph
    index: Optional position index to insert the paragraph at

Inputs: text (required), notebook_id (required), index, title. Returns: result

batch_add_paragraphA

Add multiple paragraphs to a notebook in one call (batch version of add_paragraph). Paragraphs are created sequentially in the given order.

Prefer this over many add_paragraph calls when scaffolding several cells — it collapses N
round-trips into one. One failing item does not stop the rest (failures are reported).

Args:
    notebook_id: The notebook ID to add paragraphs to
    paragraphs: List of paragraphs to create, each {text, title?, index?}.

Inputs: paragraphs (required), notebook_id (required). Returns: result

batch_delete_paragraphA
Destructive

Delete multiple paragraphs in one call (batch version of delete_paragraph). Each paragraph's content is automatically backed up before deletion.

Prefer this over many delete_paragraph calls — it collapses N round-trips into one.
Paragraphs are deleted sequentially; one failing item does not stop the rest (failures are
reported in the result).

Args:
    notebook_id: The notebook ID containing the paragraphs
    paragraph_ids: List of paragraph IDs to delete.

Inputs: notebook_id (required), paragraph_ids (required). Returns: result

batch_edit_paragraphA
Destructive

Apply several find-and-replace edits in one call (batch version of edit_paragraph), across one or more paragraphs. Previous content of each changed paragraph is backed up.

Edits are grouped by paragraph and applied in the given order, each against the result of
the previous one. Per paragraph it is all-or-nothing: if any of its edits fails, that
paragraph is left untouched. Other paragraphs still proceed (failures are reported).

Args:
    notebook_id: The notebook ID containing the paragraphs
    edits: List of edits, each {paragraph_id, old_string, new_string, replace_all?}.

Inputs: edits (required), notebook_id (required). Returns: result

batch_run_paragraphA

Run several paragraphs one after another in the given order, in a single call. Use this instead of many run_paragraph calls when you need a specific sequence of cells run — e.g. setup cells before the cells that depend on them. Paragraphs run sequentially (not in parallel) because cells typically share interpreter state, and this collapses N round-trips into one.

Each run item may carry its own dynamic form params. The top-level params dict is a shared
default merged under per-item params (the item wins on key conflicts). The same paragraph_id
may appear multiple times with different params — a parameter sweep in one call.

By default table output is limited to 50 rows and HTML output is omitted to save tokens.

Args:
    notebook_id: The notebook ID containing the paragraphs
    runs: Paragraphs to run in execution order, each {paragraph_id, params?}. Example:
        [{"paragraph_id": "p1"}, {"paragraph_id": "p2", "params": {"city": "Seoul"}}]
    params: Optional shared dynamic form values applied to every item, e.g. {"env": "prod"}.
        Per-item params override these per key.
    max_rows: Maximum data rows per table output (default 50, 0 = unlimited). Header row always included.
    include_html: If True, include HTML output converted to plain text. Default False.
    stop_on_error: If True (default), stop at the first paragraph that errors and report the
        remaining ones as skipped. If False, run every paragraph regardless of failures.

Inputs: runs (required), notebook_id (required), params, max_rows, +2 more. Returns: result

batch_update_paragraphA
DestructiveIdempotent

Update multiple paragraphs in one call (batch version of update_paragraph). Previous content of each changed paragraph is automatically backed up.

Prefer this over many update_paragraph calls when editing several paragraphs — it collapses
N round-trips into one. Paragraphs are updated sequentially; one failing item does not stop
the rest (failures are reported in the result).

For small targeted changes prefer batch_edit_paragraph, which sends only changed snippets.

Args:
    notebook_id: The notebook ID containing the paragraphs
    updates: List of edits, each {paragraph_id, text, title?}.

Inputs: updates (required), notebook_id (required). Returns: result

batch_update_paragraph_configA
Idempotent

Update visualization/chart config for multiple paragraphs in one call (batch version of update_paragraph_config). Each config is deep-merged with that paragraph's existing config. Column index/aggr auto-fill needs saved output: run each paragraph at least once first, otherwise index/aggr cannot be auto-filled and columns are passed through as given.

Prefer this over many update_paragraph_config calls — it collapses N round-trips into one.
Paragraphs are processed sequentially; one failing item does not stop the rest (failures are
reported in the result).

Args:
    notebook_id: The notebook ID containing the paragraphs
    configs: List of config changes, each {paragraph_id, config}. See update_paragraph_config
        for the config dict format (graph.mode, keys/groups/values, etc.).

Inputs: configs (required), notebook_id (required). Returns: result

clone_notebookA

Clone an existing notebook. Optionally rename the copy.

Args:
    notebook_id: The notebook ID to clone
    new_name: Optional full path/name for the cloned notebook (e.g. "Users/john/Project/Copy").
              If omitted, Zeppelin auto-generates a name in the source's parent folder.

Inputs: notebook_id (required), new_name. Returns: result

clone_paragraphA

Clone a paragraph within the same notebook. The copy is created directly below the source paragraph and carries over its code, title, and visualization/chart config. The clone's title gets a " (copy)" suffix; untitled paragraphs stay untitled.

Zeppelin has no dedicated clone-paragraph endpoint, so this reads the source paragraph,
creates a new one with the same content, then copies its config in a single tool call.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to clone

Inputs: notebook_id (required), paragraph_id (required). Returns: result

create_notebookB

Create a new empty notebook.

Args:
    name: Full path for the new notebook, e.g. "Users/john/ProjectName/Notebook Title"

Inputs: name (required). Returns: result

delete_paragraphA
Destructive

Delete a paragraph. Its content is automatically backed up before deletion.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to delete

Inputs: notebook_id (required), paragraph_id (required). Returns: result

edit_paragraphA
Destructive

Replace an exact snippet of paragraph code (find-and-replace). Previous content is automatically backed up before changes.

Prefer this over update_paragraph for targeted changes — you send only the changed snippet
instead of the whole paragraph. Use update_paragraph for whole rewrites.

old_string must match the current code exactly, including whitespace and indentation: copy it
from get_paragraph_code (raw text), not from get_notebook/get_paragraph (they indent code by
2 spaces). Keep it minimal but unique — include a neighbouring line if the snippet repeats.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to edit
    old_string: Exact existing text to replace (must occur once unless replace_all)
    new_string: Replacement text
    replace_all: Replace every occurrence instead of requiring a unique match (e.g. renames)

Inputs: new_string (required), old_string (required), notebook_id (required), paragraph_id (required), +1 more. Returns: result

export_notebookA
Read-onlyIdempotent

Export notebook as JSON (for cross-server migration or backup). Warning: output can be very large for notebooks with many paragraphs or large results.

Args:
    notebook_id: The notebook ID to export

Inputs: notebook_id (required). Returns: result

get_notebookA
Read-onlyIdempotent

Get notebook overview with all paragraph code, titles, and status. Does not include paragraph output — use get_paragraph to inspect output of specific paragraphs.

For large notebooks, prefer list_paragraphs first to identify paragraphs of interest,
then get_paragraph_code for targeted reads.

Args:
    notebook_id: The notebook ID to retrieve
    include_config: If True, include visualization/chart config and presentation
        flags (editorHide, runOnSelectionChange) for each paragraph. Default False.

Inputs: notebook_id (required), include_config. Returns: result

get_notebook_fingerprintA
Read-onlyIdempotent

Get a deterministic content fingerprint of a notebook, plus per-paragraph sub-hashes.

Cheap freshness check for cached notebook documentation. Only stable content is
hashed (paragraph id, title, code text); execution status, output, form
values/definitions, chart configs, and paragraph order are all excluded — none of
those flag the notebook stale.

The comparison against the cached doc happens server-side — never hand-compare
hash maps. Preferred: pass `spec_path` (the spec file under $WIKI_DOCS_PATH) and
the server reads the stored fingerprint/units from its frontmatter itself; the
response gains `"match": true|false` and `"diff": {changed, added, removed}`
naming the exact paragraph ids that differ. If the spec can't be used, the
response carries a `spec_note` explaining why and no match/diff. Fallback when
there is no docs repo: pass the stored values explicitly as `known_fingerprint` /
`known_units` (they take precedence over `spec_path` if both are given).

Args:
    notebook_id: The notebook ID to fingerprint
    spec_path: Optional path to the cached spec file inside $WIKI_DOCS_PATH
    known_fingerprint: Optional stored overall fingerprint to compare against
    known_units: Optional stored per-paragraph sub-hash map to diff against

Inputs: notebook_id (required), spec_path, known_units, known_fingerprint. Returns: result

get_notebook_permissionsA
Read-onlyIdempotent

Get permission information for a notebook (owners, writers, readers).

Args:
    notebook_id: The notebook ID to get permissions for

Inputs: notebook_id (required). Returns: result

get_paragraphA
Read-onlyIdempotent

Get full content of a single paragraph (code, output, dynamic forms, chart config, and presentation flags like editorHide / runOnSelectionChange).

By default, table output is limited to 50 rows and HTML output is omitted to save tokens.
When investigating data discrepancies, set max_rows=0 for unlimited rows.
If the paragraph uses HTML rendering (without z.show()), set include_html=True to see
text extracted from HTML. Alternatively, query the underlying data via SQL if available.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to retrieve
    max_rows: Maximum data rows for table output (default 50, 0 = unlimited). Header row always included.
    include_html: If True, include HTML output converted to plain text. If False (default), HTML is omitted.

Inputs: notebook_id (required), paragraph_id (required), max_rows, include_html. Returns: result

get_paragraph_codeA
Read-onlyIdempotent

Get only the code/text content of a paragraph, without output or forms. Use this instead of get_paragraph when you only need to read the code to save on output size.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to retrieve

Inputs: notebook_id (required), paragraph_id (required). Returns: result

get_paragraph_formsB
Read-onlyIdempotent

Get dynamic form definitions and current parameter values for a paragraph.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to inspect

Inputs: notebook_id (required), paragraph_id (required). Returns: result

get_paragraph_statusA
Read-onlyIdempotent

Get execution status of a specific paragraph (useful after async run).

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to check

Inputs: notebook_id (required), paragraph_id (required). Returns: result

import_notebookA

Import a previously exported notebook JSON. Optionally rename it.

Args:
    notebook_json: The full notebook JSON string from export_notebook
    new_name: Optional new name/path for the imported notebook

Inputs: notebook_json (required), new_name. Returns: result

list_notebooksA
Read-onlyIdempotent

List notebooks on the Zeppelin server.

Always use name_filter to narrow results — the server may have thousands of notebooks.

Args:
    name_filter: Optional substring filter (case-insensitive) matched against the full path.
    limit: Maximum number of notebooks to return (default 100, 0 = unlimited).

Inputs: limit, name_filter. Returns: result

list_paragraphsA
Read-onlyIdempotent

List paragraph metadata (index, id, title, status) without code or output.

Paragraphs whose presentation config deviates from the finalized standard are
marked inline: [editor visible] when editorHide is not true, and
[runs on selection change] when the paragraph has forms but
runOnSelectionChange is not false. Unmarked paragraphs are properly finalized.

Args:
    notebook_id: The notebook ID to list paragraphs for

Inputs: notebook_id (required). Returns: result

move_paragraphA
Idempotent

Move a paragraph to a new position within the same notebook.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to move
    new_index: The target position index (0-based)

Inputs: new_index (required), notebook_id (required), paragraph_id (required). Returns: result

run_all_paragraphsA

Run all paragraphs in a notebook and wait for completion. Uses the async job endpoint which preserves chart/visualization settings.

Args:
    notebook_id: The notebook ID to run
    params: Optional dict of dynamic form values, e.g. {"city": "Seoul"}.

Inputs: notebook_id (required), params. Returns: result

run_paragraphA

Run a paragraph and return the result. Uses the async job endpoint which preserves chart/visualization settings.

By default, table output is limited to 50 rows and HTML output is omitted to save tokens.
Set max_rows=0 for unlimited rows when you need full results for analysis.
Set include_html=True to see HTML output converted to plain text.

On error, the response includes the error output — examine it before retrying.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to run
    params: Optional dict of dynamic form values, e.g. {"city": "Seoul"}.
    max_rows: Maximum data rows for table output (default 50, 0 = unlimited). Header row always included.
    include_html: If True, include HTML output converted to plain text. If False (default), HTML is omitted.

Inputs: notebook_id (required), paragraph_id (required), params, max_rows, +1 more. Returns: result

run_paragraph_asyncA

Start paragraph execution and return immediately without waiting for results. Use this to run multiple paragraphs in parallel, then check status with get_paragraph_status and read results with get_paragraph.

Chart/visualization settings are preserved automatically.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to run
    params: Optional dict of dynamic form values, e.g. {"city": "Seoul"}.

Inputs: notebook_id (required), paragraph_id (required), params. Returns: result

search_notebooksB
Read-onlyIdempotent

Full-text search across all notebook paragraphs.

Args:
    query: Search query string
    max_results: Maximum number of results to return (default 20, 0 = unlimited).

Inputs: query (required), max_results. Returns: result

set_notebook_permissionsC
Idempotent

Set permission information for a notebook.

Args:
    notebook_id: The notebook ID to set permissions for
    owners: List of usernames with owner access
    writers: List of usernames with write access
    readers: List of usernames with read access
    runners: List of usernames with runner access

Inputs: owners (required), readers (required), writers (required), notebook_id (required), +1 more. Returns: result

stop_paragraphA
Idempotent

Stop a running paragraph. Use this to cancel long-running or stuck queries.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to stop

Inputs: notebook_id (required), paragraph_id (required). Returns: result

update_paragraphA
DestructiveIdempotent

Update paragraph code/text. Previous content is automatically backed up before changes.

Sends the whole new text — for small targeted changes prefer edit_paragraph, which sends
only the changed snippet.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to update
    text: The new code/content for the paragraph
    title: Optional new title for the paragraph

Inputs: text (required), notebook_id (required), paragraph_id (required), title. Returns: result

update_paragraph_configA
Idempotent

Update paragraph visualization/chart config (graph type, columns, display settings). Fetches current config and deep-merges provided changes. Column index and aggr fields are auto-filled from the paragraph's output headers — only provide name. Auto-fill needs saved output: run the paragraph at least once first, otherwise index/aggr cannot be auto-filled and columns are passed through as given.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to configure
    config: Dict of config fields to set or update. Merged with existing config.
        To change chart type, set graph.mode to one of:
        "table", "multiBarChart", "stackedAreaChart", "lineChart",
        "pieChart", "scatterChart".
        Example: {"graph": {"mode": "multiBarChart",
                            "keys": [{"name": "date_col"}],
                            "values": [{"name": "amount_col"}]}}

Inputs: config (required), notebook_id (required), paragraph_id (required). Returns: result

update_paragraph_formsA
Idempotent

Update dynamic form values without re-executing the paragraph. Safest way to change form parameters when chart settings must be preserved.

Args:
    notebook_id: The notebook ID containing the paragraph
    paragraph_id: The paragraph ID to update
    params: Dict of form values to set, e.g. {"city": "Seoul", "limit": "10"}.

Inputs: params (required), notebook_id (required), paragraph_id (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 33 tools

    Disambiguation4/5

    Tools have mostly distinct resource+action targets, and descriptions actively steer the agent (e.g., get_paragraph_code vs get_paragraph, edit_paragraph vs update_paragraph, run_paragraph vs run_paragraph_async vs batch_run_paragraph). A few overlaps remain between the get/list variants and the many run flavors, but the guidance is strong enough that an agent can pick correctly.

    Naming Consistency5/5

    Consistent verb_noun snake_case throughout: list_paragraphs, get_paragraph, update_paragraph, run_paragraph, delete_paragraph, move_paragraph, plus a uniformly prefixed batch_ family (batch_add/edit/delete/run/update). No style mixing.

    Tool Count3/5

    At 33 tools it sits firmly in heavy territory, with a full parallel batch_ variant for nearly every per-paragraph operation (add, edit, update, delete, run, config). Each earns a rationale (collapsing round-trips), but the surface is larger than the domain strictly requires.

    Completeness3/5

    Paragraph and run lifecycles are exhaustive (list/get/get_code/forms/config, add/edit/update/move/clone/delete, run/stop/status) and notebooks cover create/list/search/get/export/import/clone plus permissions. However there is no delete_notebook or notebook rename/update, leaving the notebook lifecycle incomplete.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      C
      maintenance
      Enables AI agents to interact with Microsoft Fabric by exposing tools for managing workspaces, notebooks, SQL queries, pipelines, and Livy Spark sessions. It provides a comprehensive set of operations for data engineering and analytics tasks using standard Azure authentication.
      37
      4
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to interact with Jupyter notebooks via MCP tools for querying, modifying, executing, and setting up notebooks, with state preservation and real-time collaboration.
      4
      46
      Apache 2.0