Free tools Windows power users keep installed
One-click scans. No signup required.
Datalayer’s jupyter-mcp-server connects an MCP-compatible AI client to a running Jupyter server, letting it inspect notebooks, edit cells, run code, and read outputs. The quickest local setup uses JupyterLab, a token, and uvx. This guide covers that project; a separate Jupyter extension called jupyter-server-mcp serves a different purpose.
What Jupyter MCP Server does
MCP, or Model Context Protocol, is the connection layer between an AI application and tools it can call. The AI application is the MCP host; Jupyter MCP Server exposes notebook operations as MCP tools; JupyterLab or Jupyter Server supplies the notebooks and kernels.
That is different from pasting notebook text into a chatbot, which only gives it the content you provide. It is also different from a conventional Jupyter kernel client, which can run code but does not necessarily expose notebook operations to an AI through MCP. With Datalayer’s server, a connected client can discover notebooks, read and change cells, execute code, and receive outputs. The project also documents optional execution backends beyond the default Jupyter environment.
The project is open source under the BSD 3-Clause license. PyPI showed version 1.4.4 in its release history on August 17, 2026; the package requires Python 3.10 or newer. Check the current package page before pinning a version because the project is evolving.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →#1 Best Overall
Choose the right project
“Jupyter MCP Server” can mean either of these projects. The main walkthrough below uses Datalayer’s notebook-management server.
| Project | Best for | Configuration model |
|---|---|---|
Datalayer jupyter-mcp-server |
AI-assisted notebook analysis, editing, kernel use, and execution | Connects to Jupyter using variables such as JUPYTER_URL and JUPYTER_TOKEN |
Jupyter AI Contrib jupyter-server-mcp |
Exposing custom Python functions as MCP tools from Jupyter Server | Jupyter Server extension configured with MCPExtensionApp and Python function registrations |
Use Datalayer’s package if you want tools for notebooks and cells out of the box. Choose jupyter-server-mcp if your goal is to register your own Python functions as tools.
What you need
- Python 3.10 or later.
- A working JupyterLab or Jupyter Server installation and an installed kernel, typically
ipykernel. - An MCP-compatible client that can use the transport you choose.
- A Jupyter authentication token.
uvfor the recommendeduvxlauncher, or Docker if you deliberately choose a containerized setup.
The project’s quick start installs JupyterLab, Jupyter Collaboration, Jupyter MCP Tools, and ipykernel. The appropriate dependency set can vary by release and deployment mode; avoid treating older version pins or a particular pycrdt replacement as universal requirements. Consult the package instructions for the version you install.
Set up a local Jupyter server
Run these commands in a terminal. They create an isolated Python environment and install the Jupyter packages used in the project’s current quick-start approach.
-
Create and activate a virtual environment:
python -m venv .venv # macOS/Linux source .venv/bin/activate # Windows PowerShell .venvScriptsActivate.ps1 -
Install JupyterLab, the integration packages, and a Python kernel:
python -m pip install --upgrade pip python -m pip install jupyterlab jupyter-collaboration jupyter-mcp-tools ipykernel -
Install
uvand confirm it is available:python -m pip install uv uv --versionThe project setup example specifies
uv0.6.14 or higher; check the current uv documentation and package instructions in case the requirement has changed. -
Start JupyterLab with a token, bound to the local machine:
jupyter lab --port 8888 --IdentityProvider.token MY_TOKEN --ip 127.0.0.1Replace
MY_TOKENwith a private token value. Binding to127.0.0.1keeps this local test from listening on every network interface. The project’s example also shows0.0.0.0, but use that only when you intend to make the service reachable over a network and have configured suitable protections.Recommended Free Tools
Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.
Keep this Jupyter process running. The MCP server connects to it; it does not replace it.
Configure an MCP client
Add a server entry to the configuration file used by your MCP client. This is the Datalayer quick-start configuration pattern:
{
"mcpServers": {
"jupyter": {
"command": "uvx",
"args": ["jupyter-mcp-server@latest"],
"env": {
"JUPYTER_URL": "http://localhost:8888",
"JUPYTER_TOKEN": "MY_TOKEN",
"ALLOW_IMG_OUTPUT": "true"
}
}
}
}commandstarts the MCP server process.uvxruns a Python tool in an isolated environment; see the uv documentation.argsidentifies the package to run.@latestfollows the latest available release; pin a version instead if you need repeatable installs and have checked that version.JUPYTER_URLis the base URL of the running Jupyter server, not a notebook file URL.JUPYTER_TOKENauthenticates the MCP server to Jupyter.ALLOW_IMG_OUTPUT=trueenables image output where the client and model can handle it.
Configuration filenames and supported fields vary among Claude Desktop, Cursor, VS Code, Windsurf, Gemini CLI, and other hosts. Use the client’s current MCP documentation to locate its configuration file and confirm its syntax; do not assume the JSON above can be pasted unchanged into every client. The important values to adapt are the process command, arguments, and environment variables. Keep the token out of shared repositories and synced configuration files.
Verify the connection safely
Use a disposable notebook for the first test. The connected AI can modify cells and execute code, so start with a harmless operation rather than a notebook that holds valuable data or credentials.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- Open a notebook in JupyterLab and confirm that its kernel is running.
- Start or reload the MCP client so it loads the new server entry.
- Ask:
List the notebooks available on my Jupyter server. - Ask:
Open analysis/demo.ipynb and summarize its cells without changing anything.Replace the path with one of the listed notebooks. - Ask:
Add a new code cell containing 2 + 2, execute it, and report the output. - Check JupyterLab and confirm the cell and its output appear in the notebook.
If the client cannot list or open notebooks, work through the connection checks in Troubleshooting before granting broader access.
Work with notebooks, cells, and kernels
The server’s package documentation groups tools for server and sandbox management, notebook management, and cell operations. Depending on version and configuration, examples include:
- Server and sandbox:
list_files,list_kernels,connect_to_jupyter,launch_sandbox,list_sandboxes,use_sandbox, andterminate_sandbox. Sandbox lifecycle tools require the optionaljupyter_mcp_sandboxespackage. - Notebooks:
use_notebook,list_notebooks,restart_notebook,unuse_notebook, andread_notebook. - Cells and code:
read_cell,insert_cell,delete_cell,move_cell,clear_cell_output,overwrite_cell_source,edit_cell_source,execute_cell,insert_execute_code_cell, andexecute_code. - JupyterLab mode: additional tools can include
notebook_run-all-cellsandnotebook_get-selected-cell.
The exact tools exposed depend on the installed version, enabled extensions, client capabilities, and sandbox configuration. Ask the client to list its available Jupyter tools or inspect the MCP server’s tool list instead of assuming every name is present.
Use notebook paths carefully
DOCUMENT_ID can select a default notebook. Its path is relative to the directory from which JupyterLab was started. If it is omitted, list the available notebooks and select one. A notebook’s local filesystem path, its Jupyter-root-relative path, and its browser URL are not interchangeable.
- Use a path relative to the Jupyter root rather than assuming an absolute local path will work.
- Start JupyterLab from the directory that contains the notebooks you expect to access.
- Do not URL-encode a path unless the relevant setting specifically expects an encoded value.
- A notebook outside the Jupyter root, or one on a different machine, is not made visible by giving its local path to the MCP server.
Ask for controlled changes
For sensitive work, separate inspection from editing. For example: “Work only in analysis/demo.ipynb. Before modifying anything, show me the notebook path and target cell index.” Review the proposed change, then ask for the edit and execution explicitly. This reduces wrong-notebook mistakes, but it does not replace environment isolation.
Choose STDIO or Streamable HTTP
Datalayer’s implementation supports both transports. STDIO is usually simplest for a local client that launches the MCP process. Streamable HTTP suits networked or multi-client deployments, but requires a deliberate network and authentication setup. The project’s transport documentation describes the options.
| Transport | Good fit | Trade-offs |
|---|---|---|
| STDIO | Local desktop or command-line client, single-user development, or a client that starts the MCP process | No extra MCP network port; configuration is straightforward and credentials can be passed as process environment variables. Usually tied to the client process and less convenient for multiple remote clients. |
| Streamable HTTP | Multiple clients, web applications, remote deployments, or an MCP endpoint hosted with Jupyter Server | Provides a network endpoint, but needs authentication and careful TLS, proxy, firewall, and network configuration. The Datalayer getting-started documentation says its Jupyter Server extension supports Streamable HTTP, not STDIO. |
For most local first runs, use STDIO. Choose HTTP when shared access is a real requirement and you can secure the endpoint; opening a port alone is not a complete deployment.
Connect to remote Jupyter or JupyterHub
A remote connection uses the URL and credentials of the server the MCP process must reach. With JupyterHub, that generally means the user’s single-user server URL and a JupyterHub API token with the required access:servers scope—not merely the Hub’s front-page URL. Confirm the correct endpoint and scopes with your Hub administrator.
Some advanced deployments separate document storage from code execution. The package’s configuration has evolved: newer documentation uses DOCUMENT_* and code-sandbox/runtime naming where older examples may use generic provider terminology. Match variable names to the installed release, and keep document and runtime URLs distinct when the services differ.
- Do not commit a long-lived Hub token or put it in configuration synchronized to other machines.
- Do not assume the Hub URL and a user’s single-user server URL are interchangeable.
- Use a token scoped to the intended user and server; never connect an agent to another person’s notebook environment without authorization.
- For remote HTTP, use TLS and authentication, and account for reverse-proxy, firewall, and network rules.
See the project’s security guidance for deployment-specific authentication and permission considerations.
Docker and optional execution backends
When Docker helps
Docker can make the MCP server environment more reproducible or isolated, but it adds a networking boundary. The project’s quick-start examples use host.docker.internal on macOS and Windows, and --network=host on Linux. These are not interchangeable settings: the container must be able to reach the Jupyter host, and host networking should not be copied into a production deployment without considering its security implications. See the package page for the current container invocation.
When another sandbox is useful
The default execution backend is Jupyter. The project also references Datalayer, Kaggle, Google Colab, Monty, and Modal as alternative backends. They are not enabled automatically merely by installing the main package; each has its own setup, credentials, capabilities, and constraints. Examples described by the project include short-lived Colab credentials, Modal-specific credentials, and Monty’s limited Python subset. Consult the current package documentation before selecting one.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →These alternatives are useful when their execution model fits your workload, but do not assume identical filesystem access, persistence, GPU availability, quotas, or data-handling terms. The project mentions a hosted endpoint at https://mcp.datalayer.run/mcp; hosted notebooks, GPU sandboxes, or managed execution may have separate account terms or costs. No price is asserted here. For most readers, begin locally; consider hosted services when managed infrastructure or persistent remote execution is worth the external dependency.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Secure the connection
Jupyter MCP Server gives an AI client the ability to inspect, modify, and execute code in the connected environment. Treat the MCP client as a privileged automation tool. Ordinary Jupyter execution can reach whatever the kernel’s user and environment can reach; MCP does not make that code safe by itself.
- Use a disposable environment and notebook for initial tests; use a dedicated server or kernel for ongoing agent work.
- Keep API keys, cloud credentials,
.envfiles, private datasets, and other sensitive material outside the accessible environment. - Bind local Jupyter to localhost during local testing. For a remote endpoint, use TLS, authentication, and network controls.
- Scope Hub tokens narrowly and use short-lived or revocable credentials when available.
- Review changes before executing code that can delete files, change infrastructure, or send data elsewhere.
- Enable only the tools and sandbox capabilities needed. Log tool calls in team settings, and separate document access from execution rights when your deployment supports it.
Troubleshooting
The MCP client cannot connect
- Confirm JupyterLab is still running and the configured port and base URL match it.
- Check that the token is current and has not been copied with extra whitespace.
- Confirm the MCP process can reach the Jupyter host; this often differs inside Docker or on a remote machine.
- Verify the client is loading the configuration file you edited, and that
uvxor Docker is installed and on the client process’sPATH. - Check whether the server is bound only to an interface the MCP process cannot reach, or whether a firewall or reverse proxy blocks the request.
The client finds no notebooks
- Check
JUPYTER_URLandJUPYTER_TOKEN. - Confirm the notebook is beneath the Jupyter root and that any
DOCUMENT_IDis a valid relative path. - For Hub deployments, use the correct single-user server endpoint and token scope.
- If Jupyter and the MCP process run in different containers or machines, verify their network path rather than relying on a local filesystem path.
Code runs but images do not appear
Set ALLOW_IMG_OUTPUT=true, then check that the client supports image content, the model accepts multimodal input, and the client does not discard image blocks. Also confirm that the cell produced a displayable image; saving an image file alone does not necessarily return it as notebook output. Image handling varies by client, as the package documentation notes.
The kernel is stuck or has lost state
- Stop the current execution and inspect the notebook and kernel state.
- Restart the notebook kernel with the notebook tool or in JupyterLab.
- Re-run setup and import cells deliberately.
- Do not blindly run every cell in a production notebook; a restart destroys in-memory variables and state.
The AI ran an unexpected command
Treat unexpected execution as a security incident, not just a configuration error. Stop the session, review the code and environment for unintended changes or data access, and revoke exposed credentials if necessary. The execute_code tool can run code and may support magic or shell commands depending on backend and configuration.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Alternative: expose custom functions with jupyter-server-mcp
The Jupyter AI Contrib extension is for registering Python functions as MCP tools within Jupyter Server; it is not the same notebook-management workflow as Datalayer’s package. Install it into the same environment as Jupyter Server:
python -m pip install jupyter-server-mcpCreate jupyter_config.py:
c = get_config()
c.MCPExtensionApp.mcp_name = "My Jupyter MCP Server"
c.MCPExtensionApp.mcp_port = 3001
c.MCPExtensionApp.mcp_tools = [
"os:getcwd",
]Start Jupyter with that configuration:
jupyter lab --config=jupyter_config.pyThe default MCP endpoint is http://localhost:3001/mcp. The registered tool value uses a module:function form; choose functions deliberately because an exposed function becomes callable by the connected client.
The project also provides a stdio proxy configuration:
{
"mcpServers": {
"jupyter-mcp": {
"command": "uvx",
"args": [
"--from",
"jupyter-server-mcp",
"jupyter-server-mcp-proxy"
]
}
}
}It supports direct HTTP configuration as well. The proxy can discover a running Jupyter MCP Server automatically, which is useful when the MCP port can change or several Jupyter instances may be running. Details and current configuration options are in the project documentation.
Where to go next
Start with a local, token-protected Jupyter server and STDIO client connection, then verify notebook listing and a harmless cell execution in a disposable notebook. Once that works, choose a transport and deployment that match the number of users, the required isolation, and the data the connected kernel can access.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
