Jupyter Mcp Server

Name: Jupyter Mcp Server
Author: ChengJiale150

@ChengJiale150

Repository

About Jupyter Mcp Server

An MCP service specifically developed for AI to connect and manage Jupyter Notebooks

#jupyter #mcp #notebook-management

Basic information

Config

Add this server to your MCP-compatible client using the configuration below.

{
  "mcpServers": {
    "Jupyter-MCP-Server": {
      "command": "uvx",
      "args": [
        "better-jupyter-mcp-server"
      ],
      "env": {},
      "transport": "stdio"
    }
  }
}

Tools

Connect to a notebook and corresponding kernel. It is the FIRST STEP before ANY subsequent operations.

List all currently connected Notebooks. It will return unique name, Jupyter URL and Path of all connected Notebooks

Restart the kernel of a specified Notebook, clear all imported packages and variables

Read the source content (without output) of a connected Notebook. It will return the formatted content of the Notebook (including Index, Cell Type, Execution Count and Full Source Content). ONLY used when the user explicitly instructs to read the full content of the Notebook.

List the basic information of cells. It will return Index, Type, Execution Count and First Line of the Cell. It will be used to quickly overview the structure and current status of the Notebook or locate the index of specific cells for following operations(e.g. delete, insert).

Read the detailed content of a specific cell. It will return the source code, execution count and output of the cell.

Delete a specific cell. When deleting many cells, MUST delete them in descending order of their index.

Insert a cell at the specified index. Using `append_execute_cell` as a alternative if you want to insert at the end of the notebook and then execute it. When inserting many cells, MUST insert them in ascending order of their index.

Execute a specific cell with a timeout. It will return the output of the cell.

Overwrite the content of a specific cell It will return a comparison (diff style, `+` for new lines, `-` for deleted lines) of the cell's content.

Add a new cell to the end of a Notebook and immediately execute it. It will return the output of the cell. It is highly recommended for replacing the combination of `insert_cell` and `execute_cell` at the end of the Notebook.

Execute a temporary code block (not saved to the Notebook) and will return the output. It will recommend to use in following cases: 1. Execute Jupyter magic commands 2. Debug code 3. View intermediate variable values(e.g., `print(xxx)` or `df.head()`) 4. Perform temporary statistical calculations(e.g., `np.mean(df['xxx'])`) DO NOT USE IN THE FOLLOWING CASES: 1. Import new modules and perform variable assignments that affect subsequent Notebook execution 2. Run code that requires a long time to run

Overview

What is Jupyter MCP Server?

Jupyter MCP Server is a service based on the Model Context Protocol (MCP) that gives AI tools in advanced IDEs and CLI tools the ability to connect and manage Jupyter Notebooks for tasks like data analysis, visualization, and machine learning. It supports multiple Notebooks simultaneously, interactive execution, and multimodal output (text, images, tables).

How to use Jupyter MCP Server?

Install via uvx with uvx better-jupyter-mcp-server or clone the source and run uv run fastmcp run src/better_jupyter_mcp_server/server.py. You must have a running Jupyter Server (e.g., jupyter lab --port 8888 --IdentityProvider.token YOUR_TOKEN) and provide the server URL and token in your client’s rules file. Then configure the MCP JSON with "command": "uvx" and "args": ["better-jupyter-mcp-server"] using stdio transport.

Key features of Jupyter MCP Server

MCP compatible: works in any IDE or CLI tool supporting MCP
Multi‑Notebook management: manage several Notebooks at once
Interactive execution: adapts strategy based on cell output
Multimodal output: returns text, images, tables, and more
Tools for notebook, cell, and advanced integrated operations

Use cases of Jupyter MCP Server

Data analysis and visualization with AI assistance across multiple Notebooks
Machine learning workflow management (cleaning, feature engineering, training, evaluation)
Interactive debugging of code snippets via temporary cells without saving to Notebook
Automating repetitive data science tasks by combining notebook and cell tools
Leveraging multimodal LLMs (like Gemini 2.5) for rich output interpretation

FAQ from Jupyter MCP Server

What makes Jupyter MCP Server different from other Notebook tools?

Unlike tools that only read/edit or handle a single Notebook, it manages multiple Notebooks interactively, supports multimodal output, and provides advanced integrated cells like append_execute_cell to reduce tool calls.

What are the dependencies and runtime requirements?

Python 3.12+, uv for installation, and a running Jupyter Server (Lab or Notebook) with a token. The server uses stdio transport and runs locally.

How does authentication work?

You provide the Jupyter server URL and token in your client’s rules file. The server then uses that token to authenticate all calls.

Are there any known limits or performance notes?

The connect_notebook tool can take 10–30 seconds because it starts a Kernel. Other tools execute quickly. Multimodal output requires a client that supports returning image data via MCP.

Where does data live?

Notebooks and kernels run on the configured Jupyter Server (default localhost:8888). All data stays on that server; the MCP server does not store data externally.