What can you do with this server?

This server enables AI agents to fully manage and execute Jupyter Notebooks by connecting directly to a Jupyter kernel — no JupyterLab or Notebook server required. * Connect to a Jupyter kernel: Start or reuse a kernel (e.g., python3) as the execution backend for all notebook operations. * Open or create notebooks: Attach an existing .ipynb file to the session, or create a new one if it doesn't exist. * Read all notebook cells: List all cells — either as a quick summary or in full detail including source code, outputs, and embedded images. * Inspect individual cells: Read the source code and outputs (including inline base64 PNG images) of a specific cell by index. * Insert cells: Add new code or markdown cells at any position in the notebook, or append to the end. * Edit cell source: Perform find-and-replace operations on an existing cell's source code; outputs are cleared upon edit. * Delete cells: Remove any cell from the notebook by its index. * Execute notebook cells: Run a specific code cell within the notebook context, with configurable timeout and progress reporting; results are saved back to the .ipynb file. * Execute arbitrary Python code: Run any Python code snippet directly on the kernel outside the notebook context, useful for quick experiments or inspection.

Which integrations are available for this server?

Provides tools to connect to a Jupyter kernel and manage Jupyter notebooks, including creating, editing, executing, and deleting cells.

How do I use jupyter-kernel-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@jupyter-kernel-mcp execute cell 2 in my notebook" 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.

jupyter-kernel-mcp

by qtalen

Overview Schema Related Servers Score Discussions

Python

Local

I share an in-depth data science and AI project practice every month. Visit and subscribe to https://www.dataleadsfuture.com

jupyter-mcp-kernel

An MCP (Model Context Protocol) server that connects directly to a Jupyter kernel via ZMQ — no JupyterLab or Notebook server required.

Enable your AI assistant to read, create, edit, execute, and manage Jupyter Notebooks as MCP tools.

Architecture

┌──────────────┐     stdio      ┌──────────────────┐      ZMQ      ┌────────────────┐
│  AI Agent    │ ◄────────────► │ jupyter-mcp-     │ ◄──────────► │  Jupyter IPykernel  │
│  (OpenCode)  │   MCP tools    │ kernel server    │              │  (python3)     │
└──────────────┘                └──────────────────┘              └────────────────┘
                                      │
                                ┌─────┴──────┐
                                │  .ipynb     │
                                │  (on disk)  │
                                └────────────┘

The server communicates with the kernel over ZMQ channels (iopub, shell, stdin, control) and persists notebook files to disk after every modification.

Related MCP server: cursor-notebook-mcp

Prerequisites

Python ≥ 3.10
ipykernel installed (so the kernel can start). If not sure:
```
python -m ipykernel install --user
```
uv (recommended) or pip

Installation

Option A: Install from GitHub (recommended for end users)

uv tool install git+https://github.com/qtalen/jupyter-mcp-kernel.git

This makes the jupyter-mcp-kernel command available globally (managed by uv).

Option B: Install from local source (for development)

git clone https://github.com/qtalen/jupyter-mcp-kernel.git
cd jupyter-mcp-kernel
uv tool install --path . jupyter-mcp-kernel

Option C: Install via pip

pip install git+https://github.com/qtalen/jupyter-mcp-kernel.git

Register with OpenCode

Add the following mcp entry to your project's opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jupyter": {
      "type": "local",
      "command": ["jupyter-mcp-kernel", "--cell-timeout", "7200"],
      "enabled": true,
      "timeout": 7200000
    }
  }
}

Then restart OpenCode. The 8 MCP tools will appear automatically.

Available Tools

All tools are registered as @mcp.tool() and are callable by your AI agent once the MCP server is connected.

1. `connect_to_jupyter`

Item	Value
Description	Start (or reuse) a Jupyter kernel. Must be called before any other operation.
Parameters	`kernel_name` (str, default `"python3"`) — the kernel spec name
Returns	`str` — confirmation message

2. `use_notebook`

Item	Value
Description	Open an existing `.ipynb` file, or create a new one if it doesn't exist. Attaches the notebook to the current session.
Parameters	`path` (str) — file path; `kernel_name` (str, default `"python3"`)
Returns	`str` — path and cell count

3. `read_notebook`

Item	Value
Description	List all cells. In simple mode, returns a TSV summary (index, type, preview, output count). In detailed mode, returns full source + outputs for every cell.
Parameters	`detailed` (bool, default `False`)
Returns	`list[TextContent

4. `read_cell`

Item	Value
Description	Read a single cell's source code and its outputs.
Parameters	`cell_index` (int, default `0`)
Returns	`list[TextContent

5. `insert_cell`

Item	Value
Description	Insert a new code or markdown cell at a specified index.
Parameters	`source` (str) — cell content; `index` (int, default `-1` = append); `cell_type` (str, `"code"` or `"markdown"`)
Returns	`str` — confirmation message

6. `edit_cell_source`

Item	Value
Description	Find and replace text in an existing cell's source. Clears outputs.
Parameters	`cell_index` (int); `old_string` (str); `new_string` (str)
Returns	`str` — confirmation or error

7. `delete_cell`

Item	Value
Description	Remove a cell by index.
Parameters	`cell_index` (int)
Returns	`str` — confirmation

8. `execute_cell`

Item	Value
Description	Execute a code cell in the open notebook. Supports long execution with timeout and progress reporting. Results are saved back to the `.ipynb` file.
Parameters	`cell_index` (int); `timeout_seconds` (int or None, default: `--cell-timeout` CLI value); `progress_interval` (int, default `5`, set to `0` to disable progress)
Returns	`list[TextContent

9. `execute_code`

Item	Value
Description	Execute arbitrary Python code directly on the kernel (outside the notebook context). Useful for quick experiments or inspection.
Parameters	`code` (str); `timeout` (int, default `60`)
Returns	`list[TextContent

Typical Workflow

A typical AI-driven notebook session follows these steps:

connect_to_jupyter(kernel_name="python3")
  → "Kernel ready — python3"

use_notebook(path="notebooks/my_analysis.ipynb")
  → "Using notebook: C:/.../my_analysis.ipynb (0 cells)"

insert_cell(source="# My Analysis\n\n## Objective\n...", index=0, cell_type="markdown")
  → "Inserted markdown cell at index 0"

insert_cell(source="import pandas as pd\ndf = pd.read_csv('data.csv')", index=1)
  → "Inserted code cell at index 1"

execute_cell(cell_index=1)
  → [...] + "[COMPLETED in 2s]"

read_cell(cell_index=1)
  → Shows source + any output

edit_cell_source(cell_index=1, old_string="data.csv", new_string="data_v2.csv")
  → "Cell 1 updated: replaced 1 occurrence of 8 → 11 chars"

execute_cell(cell_index=1)
  → [...] + "[COMPLETED in 3s]"

delete_cell(cell_index=2)
  → "Deleted cell 2 (code)"

CLI Options

jupyter-mcp-kernel [--cell-timeout SECONDS]

Option	Default	Description
`--cell-timeout`	`7200`	Default execution timeout per cell (seconds). Can be overridden per-call via `execute_cell(timeout_seconds=...)`.

Troubleshooting

Kernel fails to start

Ensure ipykernel is installed: python -m ipykernel install --user
Verify the kernel name. Run jupyter kernelspec list to see available kernels.
Check for proxy issues. The server automatically adds localhost,127.0.0.1 to NO_PROXY.

No tools appear in OpenCode

Confirm jupyter-mcp-kernel is on your PATH: jupyter-mcp-kernel --help
Check opencode.json syntax and path.
Restart OpenCode entirely after configuration changes.

Cell execution hangs indefinitely

The default timeout is 7200s (2h). Use execute_cell(timeout_seconds=120) for shorter tasks.
The kernel may be stuck. Use execute_cell(progress_interval=5) to see progress updates.
OpenCode can cancel execution via SIGINT → the server will interrupt the kernel.

Windows-specific

The server registers SIGBREAK (Ctrl+Break) for graceful shutdown on Windows.
Paths with spaces are supported if quoted correctly in opencode.json.

License

MIT

Available Tools

9 tools

connect_to_jupyterC

Connect to a Jupyter kernel. Starts one if not already running.

ParametersJSON Schema

Name	Required	Description	Default
`kernel_name`	No		python3

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations, the description carries full burden. It discloses that it may start a kernel, but omits other behavioral aspects like idempotency, side effects, or auth requirements. Minimal transparency beyond the core action.

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 short sentences, no redundant words, front-loaded with the main purpose. Every sentence earns its place.

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

Completeness2/5

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

Despite having an output schema, the description does not hint at return values or error conditions. It lacks context about how this tool fits into the workflow (e.g., required before using cell tools). Completeness is low.

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

Parameters1/5

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

The only parameter (kernel_name) has 0% schema description coverage and is not mentioned in the tool description. The description adds no meaning about valid values, defaults, or purpose beyond the schema's property title.

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 action (connect) and the resource (Jupyter kernel), with additional behavior (starts if not running). It distinguishes well from siblings, which operate on notebook cells rather than the kernel.

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

Usage Guidelines2/5

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

No guidance on when to use this tool vs alternatives (e.g., if already connected) or prerequisites. The description implies it's foundational, but does not explicitly say to use it before other notebook tools.

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

delete_cellC

Delete a cell by index.

ParametersJSON Schema

Name	Required	Description	Default
`cell_index`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations, the description carries full burden for behavioral disclosure. The description confirms a destructive operation but fails to specify effects on other cells (e.g., re-indexing), reversibility, or error conditions (e.g., index out of bounds).

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

Conciseness4/5

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

The description is a single sentence, front-loading the core purpose. It is concise but omits necessary details such as context (notebook) and error handling, making it slightly under-specified for a production tool.

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

Completeness2/5

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

Although an output schema exists (reducing need for return value explanation), the description lacks completeness regarding prerequisites (e.g., notebook must be open via use_notebook) and edge cases (e.g., deleting the last cell). This limits an AI agent's ability to invoke the tool correctly in all scenarios.

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

Parameters2/5

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

The single parameter cell_index lacks schema description coverage (0%). The description adds minimal meaning—'by index'—but does not specify indexing base (0- or 1-based), valid range, or behavior for invalid values. This is insufficient for correct invocation.

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 'Delete a cell by index' clearly states the action (delete), the resource (a cell), and the method (by index). It unambiguously distinguishes this tool from siblings like insert_cell or edit_cell_source, which perform different operations on cells.

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

Usage Guidelines2/5

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

No guidance is provided on when to use this tool versus alternatives (e.g., clearing a cell's content instead of deleting it). There is no mention of prerequisites, such as the need for an active notebook, or any conditions under which deletion is appropriate.

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

edit_cell_sourceC

Find and replace text in a cell's source code.

ParametersJSON Schema

Name	Required	Description	Default
`cell_index`	Yes
`new_string`	Yes
`old_string`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

The description mentions 'find and replace' implying mutation, but it does not disclose key behaviors: whether all occurrences are replaced, case sensitivity, error handling when old_string is not found, or side effects on cell execution state. With no annotations, the description carries the full burden and falls short.

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

Conciseness4/5

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

The description is a single concise sentence that front-loads the action. However, it may be too brief; some additional details could fit without harming conciseness.

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

Completeness2/5

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

Given the lack of annotations and parameter descriptions, the description is insufficient. It does not cover indexing, replacement behavior, or return value (output schema exists but is undocumented). Essential context for correct tool use is missing.

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

Parameters2/5

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

Although the description implies the roles of old_string and new_string, it fails to specify the cell_index convention (0-based or 1-based) or any constraints. With 0% schema coverage, the description adds minimal meaning beyond parameter names.

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 'Find and replace text in a cell's source code' clearly states the verb (find and replace) and resource (cell's source code), and it distinguishes the tool from siblings like read_cell or execute_cell, which have different purposes.

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

Usage Guidelines2/5

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

No guidance is provided on when to use this tool versus alternatives. The description lacks any context-specific advice, such as when to prefer edit_cell_source over other cell manipulation tools like insert_cell or delete_cell.

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

execute_cellC

Execute a code cell in the open notebook and save results.

ParametersJSON Schema

Name	Required	Description	Default
`cell_index`	Yes
`timeout_seconds`	No
`progress_interval`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.6/5.0

Behavior2/5

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

With no annotations, the description must fully disclose behaviors. It only states 'execute and save results' without detailing side effects (e.g., modifying notebook state, returning output, error handling, permissions, or potential data loss).

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

Conciseness2/5

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

While short, the description is under-specified. One sentence does not convey enough context for a tool that executes code, and no structuring (e.g., front-loading) compensates for the lack of detail.

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

Completeness2/5

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

Despite having an output schema, the description fails to cover essential aspects: parameter semantics, usage context, behavioral traits, and how results are saved. It is inadequate for an execution tool.

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

Parameters1/5

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

Schema description coverage is 0%, yet the description provides no explanation of parameters like cell_index, timeout_seconds, or progress_interval. The agent receives no guidance on how to use these fields.

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 tool executes a code cell in the open notebook and saves results, using a specific verb and resource. It distinguishes itself from siblings like read_cell (read-only) and delete_cell, which target different actions on cells.

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

Usage Guidelines2/5

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

No guidance on when to use this tool versus alternatives like execute_code (which may have different scope). No exclusions or prerequisites are mentioned, leaving the agent without a clear decision boundary.

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

execute_codeA

Execute arbitrary Python code directly (outside the notebook context).

ParametersJSON Schema

Name	Required	Description	Default
`code`	Yes
`timeout`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior2/5

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

No annotations are provided, and the description does not disclose behaviors such as execution environment isolation, side effects, error handling, or timeout behavior. The brief description leaves significant gaps for a tool that executes arbitrary code.

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?

The description is a single, clear sentence with no unnecessary words, making it highly concise and front-loaded.

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

Completeness2/5

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

Despite having an output schema, the description does not mention return values, error responses, or security considerations. For a tool that executes arbitrary code, this is insufficiently complete.

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

Parameters2/5

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

Schema description coverage is 0%, and the description adds no meaning to the parameters beyond the schema field names. It does not explain the format of the 'code' parameter or the implications of the 'timeout' parameter.

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 'Execute' and the resource 'arbitrary Python code directly (outside the notebook context)', which distinguishes it from sibling tools like execute_cell that operate within a notebook context.

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?

The description provides clear context by specifying 'outside the notebook context', implying when to use this tool over notebook-specific alternatives, but it does not explicitly list when not to use it or name alternatives.

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

insert_cellB

Insert a new code or markdown cell at the given index.

ParametersJSON Schema

Name	Required	Default
`index`	No
`source`	Yes
`cell_type`	No	code

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.2/5.0

Behavior2/5

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

No annotations are provided, so the description must convey behavioral traits. It mentions inserting a cell but does not disclose side effects (e.g., shifting subsequent indices), index behavior when default -1 is used, or error handling for invalid cell types. The presence of an output schema reduces the burden slightly, but the lack of any behavioral context is a significant gap.

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?

The description is a single, front-loaded sentence with no wasted words. It conveys the core action efficiently.

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

Completeness3/5

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

Given the tool's simplicity and the presence of an output schema, the description is somewhat adequate but leaves gaps. It does not explain index handling, cell_type constraints, or return value. More detail would improve completeness, but it covers the essential action.

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

Parameters2/5

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

Schema description coverage is 0%, so the description must compensate. It clarifies that cell_type can be 'code' or 'markdown', but does not elaborate on the index parameter (e.g., that -1 appends) or the source parameter. The added meaning is minimal beyond what the parameter names already imply.

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 'Insert', the resource 'new code or markdown cell', and the context 'at the given index'. It distinguishes from sibling tools like delete_cell, edit_cell_source, and read_cell by specifying insertion of a new cell.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives, such as edit_cell_source for modifying existing cells or delete_cell for removal. No context for appropriate use cases is given.

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

read_cellA

Read a single cell by index with its outputs.

ParametersJSON Schema

Name	Required	Description	Default
`cell_index`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior3/5

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

Without annotations, description carries full burden. It indicates a read operation with no side effects, but does not explicitly state read-only behavior, error conditions, or return limitations.

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?

Single sentence front-loads purpose with no wasted words. Maximally concise while being informative.

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?

Given simple tool (1 param, output schema exists), description covers essence. Could mention error handling or example usage, but not required for basic completeness.

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

Parameters3/5

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

Schema coverage is 0%, so description must add meaning. It explains 'cell_index' as 'by index', adding context beyond type/default, but does not specify indexing (0-based, integer range) or behavior for invalid indices.

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?

Description uses specific verb 'Read' and resource 'cell' with qualifiers 'by index' and 'with its outputs', clearly distinguishing it from siblings like delete_cell, edit_cell_source, and execute_cell.

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

Usage Guidelines3/5

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

Description implies use when needing to read a cell's code and outputs, but provides no explicit guidance on when to use versus alternatives like read_notebook or execute_cell.

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

read_notebookB

List all cells in the open notebook with optional detailed content.

ParametersJSON Schema

Name	Required	Description	Default
`detailed`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.3/5.0

Behavior2/5

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It fails to explain what 'open notebook' means, how the notebook is opened, or what 'detailed content' includes. The tool's safety profile or side effects are not addressed.

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

Conciseness4/5

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

The description is a single, concise sentence that is front-loaded with the core action. However, it could be slightly more structured by separating the purpose and the optional parameter detail. No waste.

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

Completeness3/5

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

Given the presence of an output schema (though unseen) and a simple single-parameter input, the description provides the essential functionality. However, it lacks context on prerequisites (e.g., notebook must be open) and does not elaborate on result format. Adequate but not comprehensive.

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

Parameters2/5

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

Schema coverage is 0%, so the description must compensate. It mentions 'optional detailed content' vaguely linking to the 'detailed' parameter, but does not specify what information the detailed flag reveals. The semantics remain unclear.

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 'List' and the resource 'cells in the open notebook'. It distinguishes itself from siblings like read_cell (single cell) and execute_cell (execution). The purpose is specific and unambiguous.

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

Usage Guidelines3/5

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

The description implies usage for listing all cells, contrasting with read_cell for a single cell, but no explicit when-to-use or when-not-to-use guidance is provided. Alternatives among siblings are not mentioned.

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

use_notebookC

Open or create a notebook file and attach it to the session.

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes
`kernel_name`	No		python3

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

No annotations provided; description fails to disclose conditions (e.g., behavior when file exists vs. new), side effects, or permissions required. Vague about 'attach to session' implications.

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

Conciseness4/5

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

Single sentence of 10 words, front-loaded with action and object. Efficient but omits necessary detail; could be expanded without losing conciseness.

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

Completeness2/5

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

Given output schema exists and sibling tools, description fails to explain return values or how this tool fits into notebook workflow. Missing essential context for a tool with 2 parameters and no schema descriptions.

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

Parameters2/5

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

Schema has 0% coverage and description does not explain 'path' (e.g., format, required extension) or 'kernel_name' (e.g., allowed kernels). No added semantic value beyond raw schema.

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?

Description clearly states verb ('open or create') and object ('notebook file') with result ('attach to session'), distinguishing it from sibling tools like 'read_notebook' or 'execute_cell'.

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

Usage Guidelines2/5

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

No guidance on when to use this tool vs. alternatives (e.g., 'connect_to_jupyter', 'read_notebook'). Missing context for decision-making.

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

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0

Disambiguation4/5

Tools have mostly distinct purposes, but 'execute_cell' and 'execute_code' could confuse agents due to similar names despite different contexts. Other tools are clearly separated.

Naming Consistency4/5

Most tools follow a verb_noun pattern (e.g., delete_cell, insert_cell), but 'connect_to_jupyter' and 'edit_cell_source' deviate slightly. Overall consistent.

Tool Count5/5

9 tools is well-scoped for a Jupyter kernel server, covering connection, notebook management, cell operations, and code execution without excess.

Completeness3/5

Covers core CRUD for cells and execution, but missing kernel management tools like restart or interrupt, and no explicit save/close functionality.

Maintenance

ActivityStale

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

mcp-server
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
Zapier
com.zapier
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
App Automation Workplace & Productivity
2297
Backtest360 A
com.backtest360
MCP server exposing the Backtest360 engine API as tools for AI agents.
Finance Research & Data
202
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237

Related MCP Servers

JupyterMCP
Developer Tools Code Execution
ilylty
F
license
Not graded
quality
D
maintenance
A Model Control Protocol (MCP) server that enables remote programmatic control of Jupyter notebooks, allowing AI assistants and applications to create, edit, and execute notebook cells via SSE protocol.
Updated a year ago (2025-05-14 04:41 UTC)
cursor-notebook-mcp
File Systems Developer Tools
jbeno
F
license
Not graded
quality
C
maintenance
An MCP server that enables AI agents to create, read, edit, and manage Jupyter Notebook files programmatically, overcoming limitations in Cursor's native notebook support.
Updated 10 months ago (2025-11-08 05:09 UTC)
161
Jupyter MCP Server
Code Execution Data Platforms Data Visualization
ChengJiale150
A
license
A
quality
D
maintenance
AI-powered MCP server for connecting and managing Jupyter Notebooks. Enables interactive code execution, multi-notebook management, and multimodal output for data analysis, visualization, and machine learning.
Updated 10 months ago (2025-11-01 05:47 UTC)
12
9
MIT
notebook-editor
Code Execution Developer Tools
linzk-bit
F
license
Not graded
quality
C
maintenance
A local MCP server for reading, writing, and executing Jupyter notebooks using jupyter_client for direct kernel communication.
Updated 3 months ago (2026-06-12 09:57 UTC)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/qtalen/jupyter-mcp-kernel'

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

jupyter-mcp-kernel

Architecture

Prerequisites

Installation

Option A: Install from GitHub (recommended for end users)

Option B: Install from local source (for development)

Option C: Install via pip

Register with OpenCode

Available Tools

1. connect_to_jupyter

2. use_notebook

3. read_notebook

4. read_cell

5. insert_cell

6. edit_cell_source

7. delete_cell

8. execute_cell

9. execute_code

Typical Workflow

CLI Options

Troubleshooting

Kernel fails to start

No tools appear in OpenCode

Cell execution hangs indefinitely

Windows-specific

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `connect_to_jupyter`

2. `use_notebook`

3. `read_notebook`

4. `read_cell`

5. `insert_cell`

6. `edit_cell_source`

7. `delete_cell`

8. `execute_cell`

9. `execute_code`