Apache Zeppelin MCP Server
Allows interaction with Apache Zeppelin notebooks, providing tools for managing notebooks, paragraphs, executing code, searching, and backup operations via the Zeppelin REST API.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Apache Zeppelin MCP Server List my Apache Zeppelin notebooks"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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, with optional |
| Full-text search across all notebook paragraphs, with |
| Get notebook overview with all paragraph code, titles, and status (no output) |
| List paragraph metadata (index, id, title, status) without code or output |
| Get full content of a single paragraph (code, output, and dynamic forms) |
| Get only the code/text content of a paragraph, without output or forms (saves tokens) |
| Get dynamic form definitions and current parameter values for a paragraph |
| Update dynamic form values without re-executing (preserves chart settings) |
| Update paragraph visualization/chart config (graph type, column mappings, display settings) |
| Batch: update visualization/chart config for several paragraphs in one call |
| Update paragraph code/text with automatic backup of previous version |
| Batch: update several paragraphs in one call (each changed paragraph is backed up) |
| Find-and-replace inside a paragraph's code — send only the changed snippet instead of the whole text (with automatic backup) |
| 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 a paragraph with automatic backup of its content |
| Batch: delete several paragraphs in one call (each is backed up first) |
| Move a paragraph to a new position within the same notebook |
| Create a new empty notebook |
| Add a new paragraph to an existing notebook |
| Batch: add several paragraphs in one call, created in the given order |
| Clone a paragraph (code, title, and chart config) directly below the original |
| Run a paragraph and return the result (preserves chart settings) |
| Batch: run several paragraphs sequentially in a given order, each optionally with its own dynamic-form params (stops on first error by default) |
| Start paragraph execution without waiting — for parallel runs, check status with get_paragraph_status |
| Run all paragraphs in a notebook and wait for completion (preserves chart settings) |
| Check execution status of a paragraph |
| Stop a running paragraph (cancel long-running or stuck queries) |
| Get permission information for a notebook (owners, writers, readers) |
| Set owners, writers, and readers for a notebook |
| Export notebook as JSON for backup or cross-server migration |
| Import a previously exported notebook JSON |
| 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
Claude Code plugin (recommended) — one command installs the MCP server and the skills, and auto-updates on every commit. See below.
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.
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
Setup as a Claude Code plugin (recommended)
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"In Claude Code:
/plugin marketplace add german-borisevich/apache-zeppelin-mcp
/plugin install apache-zeppelin@apache-zeppelin-mcpRestart the session. The Zeppelin MCP tools and the
/notebook,/review_notebookskills are now available, and the plugin auto-updates at session start whenever this repo gets new commits.
Setup for Claude Desktop
Open Claude Desktop settings and navigate to the MCP servers configuration file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Add the Zeppelin server to the
mcpServerssection:
{
"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.
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.pyReplace the URL, credentials, and path with your actual values.
To verify it was added:
claude mcp listTo remove it later:
claude mcp remove zeppelinProject-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.jsoncontains 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.pyIf 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.pyThis opens a browser where you can:
See all 30 registered tools
Call
list_notebooksto verify the connection to Zeppelin is workingTest
search_notebookswith a keywordTry
get_notebookwith a notebook ID from the listCreate 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:
Open a new conversation
Click the hammer icon at the bottom of the input box — you should see all 30 Zeppelin tools listed
Ask Claude: "List all my Zeppelin notebooks"
Claude will call
list_notebooksand show the results
If the tools don't appear, check the Claude Desktop logs:
macOS:
~/Library/Logs/Claude/mcp*.logWindows:
%APPDATA%\Claude\Logs\mcp*.log
4. Test from Claude Code
After adding the server with claude mcp add:
Start Claude Code:
claudeAsk: "List all my Zeppelin notebooks"
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 statusIf 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_paragraphandedit_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_paragraphProtection: All mutating tools (add, run, update, delete, move, set permissions) are blocked from operating on
~Backupsnotebooks. 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 | Missing env vars | Set all three env vars ( |
| Zeppelin is unreachable | Verify |
Tool error | Wrong credentials | Check |
Tools don't appear in Claude Desktop | Config error or server crash | Check the MCP log files and verify |
Tools don't appear in Claude Code | Server not registered | Run |
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 toolsadd_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_paragraphADestructive
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_paragraphADestructive
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_paragraphADestructiveIdempotent
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_configAIdempotent
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_paragraphADestructive
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_paragraphADestructive
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_notebookARead-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_notebookARead-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_fingerprintARead-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_permissionsARead-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_paragraphARead-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_codeARead-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_formsBRead-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_statusARead-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_notebooksARead-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_paragraphsARead-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_paragraphAIdempotent
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_notebooksBRead-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_permissionsCIdempotent
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_paragraphAIdempotent
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_paragraphADestructiveIdempotent
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_configAIdempotent
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_formsAIdempotent
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
Scored across 33 tools
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.
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.
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.
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
Related MCP Connectors
Query and update Teable records, manage tables, and access the Teable API with AI agents.
Access Pollinations models and API capabilities through agent tools.
LLM Orchestration Agent (Opentelemetry Api)
Lets AI agents analyze API metrics, request logs, and traces, and manage apps and alerts.
Related MCP Servers
- AlicenseBqualityCmaintenanceEnables 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.374MIT
- FlicenseAqualityDmaintenanceEnables AI agents to query and interact with Google NotebookLM notebooks to retrieve citation-backed information. It provides tools for listing notebooks, accessing source data, and asking natural language questions.11-
- AlicenseAqualityDmaintenanceEnables 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.446Apache 2.0
- AlicenseAqualityDmaintenanceEnables AI agents to create, read, edit, and execute Jupyter notebook cells, manage kernels, and connect to remote Jupyter servers.2122 PyPIMIT