Skip to content
Back to search

jupyter-mcp-server

🪐 🔧 Model Context Protocol (MCP) Server for Jupyter.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/datalayer/jupyter-mcp-server with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/datalayer/jupyter-mcp-server'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/datalayer--jupyter-mcp-server/badge.svg)](/listings/datalayer--jupyter-mcp-server)

HTML

<a href="/listings/datalayer--jupyter-mcp-server"><img src="/api/listings/datalayer--jupyter-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

For comprehensive setup instructions—including `Streamable HTTP` transport, running as a Jupyter Server extension and advanced configuration—check out [our documentation](https://jupyter-mcp-server.datalayer.tech). Or, get started quickly with `JupyterLab` and `STDIO` transport here below.

1. Set Up Your Environment

pip install jupyterlab jupyter-collaboration jupyter-mcp-tools ipykernel

---

To confirm your environment is correctly configured:

1. Open a notebook in JupyterLab 1. Type some content in any cell (code or markdown) 1. Observe the tab indicator: you should see an "×" appear next to the notebook name, indicating unsaved changes 1. Wait a few seconds—the "×" should automatically change to a "●" without manually saving

This automatic saving behavior confirms that the real-time collaboration features are working properly, which is essential for MCP server integration.

---

2. Start JupyterLab

# Start JupyterLab on port 8888, allowing access from any IP and setting a token
jupyter lab --port 8888 --IdentityProvider.token MY_TOKEN --ip 0.0.0.0

---

If you are running notebooks through JupyterHub instead of JupyterLab as above, refer to our [JupyterHub setup guide](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/jupyterhub).

---

3. Configure Your Preferred MCP Client

Next, configure your MCP client to connect to the server. We offer two primary methods—choose the one that best fits your needs:

- **📦 Using `uvx` (Recommended for Quick Start):** A lightweight and fast method using `uv`. Ideal for local development and first-time users. - **🐳 Using `Docker` (Recommended for Production):** A containerized approach that ensures a consistent and isolated environment, perfect for production or complex setups.

<details> <summary><b>📦 Using uvx (Quick Start)</b></summary>

First, install `uv`:

pip install uv
uv --version
# should be 0.6.14 or higher

See more details on [uv installation](https://docs.astral.sh/uv/getting-started/installation/).

Then, configure your client:

{
  "mcpServers": {
    "jupyter": {
      "command": "uvx",
      "args": ["jupyter-mcp-server@latest"],
      "env": {
        "JUPYTER_URL": "http://localhost:8888",
        "JUPYTER_TOKEN": "MY_TOKEN",
        "ALLOW_IMG_OUTPUT": "true"
      }
    }
  }
}

</details>

<details> <summary><b>🐳 Using Docker (Production)</b></summary>

**On macOS and Windows:**

{
  "mcpServers": {
    "jupyter": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "JUPYTER_URL",
        "-e", "JUPYTER_TOKEN",
        "-e", "ALLOW_IMG_OUTPUT",
        "datalayer/jupyter-mcp-server:latest"
      ],
      "env": {
        "JUPYTER_URL": "http://host.docker.internal:8888",
        "JUPYTER_TOKEN": "MY_TOKEN",
        "ALLOW_IMG_OUTPUT": "true"
      }
    }
  }
}

**On Linux:**

{
  "mcpServers": {
    "jupyter": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "JUPYTER_URL",
        "-e", "JUPYTER_TOKEN",
        "-e", "ALLOW_IMG_OUTPUT",
        "--network=host",
        "datalayer/jupyter-mcp-server:latest"
      ],
      "env": {
        "JUPYTER_URL": "http://localhost:8888",
        "JUPYTER_TOKEN": "MY_TOKEN",
        "ALLOW_IMG_OUTPUT": "true"
      }
    }
  }
}

</details>

---

1. **Port Configuration**: Ensure the `port` in your Jupyter URLs matches the one used in the `jupyter lab` command. For simplified config, set this in `JUPYTER_URL`. 1. **Server Separation**: Use `JUPYTER_URL` when both services are on the same server, or set individual variables for advanced deployments. The different URL variables exist because some deployments separate notebook storage (`DOCUMENT_URL`) from kernel execution (`CODE_SANDBOX_URL`).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 454 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <!--
  2. ~ Copyright (c) 2024- Datalayer, Inc.
  3. ~
  4. ~ BSD 3-Clause License
  5. -->
  6. <a href="https://datalayer.ai"><img alt="Datalayer" src="https://images.datalayer.io/brand/logos/datalayer-horizontal.svg" height="22"/></a>
  7. [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)
  8. <div align="center">
  9. <!-- omit in toc -->
  10. # 🪐🔧 Jupyter MCP Server
  11. **An [MCP](https://modelcontextprotocol.io) server developed for AI to connect and manage [Jupyter](https://jupyter.org) Notebooks in real-time — and scale your [Code Sandbox](https://jupyter-mcp-server.datalayer.tech/code-sandboxes) from local to the cloud (Datalayer, Kaggle, Google Colab, Modal, Daytona, E2B, CoreWeave, Cloudflare...)**
  12. *Developed by [Datalayer](https://datalayer.ai) - Join our [Discord](https://discord.gg/YQFwvmSSuR)*
  13. [![PyPI - Version](https://img.shields.io/pypi/v/jupyter-mcp-server?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/jupyter-mcp-server) [![Total PyPI downloads](https://img.shields.io/pepy/dt/jupyter-mcp-server?style=for-the-badge&logo=python&logoColor=white)](https://pepy.tech/project/jupyter-mcp-server) [![Docker Pulls](https://img.shields.io/docker/pulls/datalayer/jupyter-mcp-server?style=for-the-badge&logo=docker&logoColor=white&color=2496ED)](https://hub.docker.com/r/datalayer/jupyter-mcp-server) [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue?style=for-the-badge&logo=open-source-initiative&logoColor=white)](https://opensource.org/licenses/BSD-3-Clause)
  14. [![Built and maintained by Datalayer](https://img.shields.io/badge/Built%20and%20maintained%20by-Datalayer%20%C2%B7%20datalayer.ai-1ABC9C?style=for-the-badge&logo=jupyter&logoColor=white&labelColor=0E7C6B)](https://datalayer.ai)
  15. </div>
  16. 📖 [Documentation](https://jupyter-mcp-server.datalayer.tech) &nbsp;·&nbsp; 🔧 [Tools](https://jupyter-mcp-server.datalayer.tech/mcp) &nbsp;·&nbsp; 💬 [Community](https://jupyter-mcp-server.datalayer.tech/community)
  17. [![HOT NEWS](https://img.shields.io/badge/%F0%9F%94%A5%20HOT%20NEWS-Hosted%20MCP%20is%20live-E74C3C?style=for-the-badge&labelColor=922B21)](https://datalayer.ai)
  18. **No process to run.** Datalayer now hosts this server for you at
  19. **`https://mcp.datalayer.run/mcp`** — one endpoint for every agent and every notebook.
  20. Sign in from your browser, approve what the agent may do, and your work keeps running
  21. on the server after the agent disconnects.
  22. → [**Hosted Jupyter MCP Server**](https://datalayer.ai)
  23. [![Jupyter MCP Server 2](https://images.datalayer.io/products/jupyter-mcp-server/jupyter-mcp-server-2.png)](https://datalayer.ai)
  24. [![Claude Code plugin](https://img.shields.io/badge/%F0%9F%A4%96%20Claude%20Code-plugin%20available-8E44AD?style=for-the-badge&labelColor=5B2C6F)](https://github.com/datalayer/jupyter-mcp-server/tree/main/extensions/claude-plugin)
  25. **One command to connect Claude Code**, with `/datalayer:notebook`, `/datalayer:run` and
  26. `/datalayer:status` on top:
  27. ```
  28. /plugin marketplace add datalayer/jupyter-mcp-server
  29. /plugin install datalayer
  30. ```
  31. → [**Datalayer plugin for Claude Code**](https://github.com/datalayer/jupyter-mcp-server/tree/main/extensions/claude-plugin)
  32. ---
  33. **Free and open source, BSD 3-Clause** — point it at any Jupyter you already run, local or
  34. JupyterHub, no account needed.
  35. Built and maintained by [**Datalayer**](https://datalayer.ai), where the same server drives
  36. always-on Notebooks with GPU Code Sandboxes and durable execution — so your agent keeps
  37. working on your data when your laptop does not.
  38. [![Discover Datalayer](https://img.shields.io/badge/%E2%86%92%20Discover%20Datalayer-datalayer.ai-1ABC9C?style=for-the-badge&labelColor=0E7C6B)](https://datalayer.ai)
  39. ---
  40. [![New: OAuth 2.1](https://img.shields.io/badge/%F0%9F%94%90%20New-OAuth%202.1%20sign--in-2E86C1?style=for-the-badge&labelColor=1B4F72)](https://jupyter-mcp-server.datalayer.tech/security/oauth)
  41. **No token to copy and paste.** An agent that meets this server unauthenticated is told
  42. where to authenticate, opens your browser, and you sign in to Datalayer as yourself. The
  43. agent never sees your password — it receives a token scoped to what you approved, and you
  44. can disconnect one agent without touching the others.
  45. What each agent may do is two separate decisions: the **scopes** you approve
  46. (`notebooks:read`, `notebooks:write`, `code:execute`, `data:read`) say what kind of
  47. operation it may perform, and your own Datalayer permissions still say which notebooks it
  48. may touch. An agent can never reach a notebook you cannot.
  49. Personal access tokens keep working, and remain the simpler path for a CLI or a script.
  50. → [**OAuth and identity**](https://jupyter-mcp-server.datalayer.tech/security/oauth)
  51. [![Hot fix](https://img.shields.io/badge/%F0%9F%9A%A8%20Hot%20fix-pin%20code--sandboxes-C0392B?style=for-the-badge&labelColor=7B241C)](https://jupyter-mcp-server.datalayer.tech/releases)
  52. **Pin `code-sandboxes` to match your `jupyter-mcp-server`.** The sandbox variant
  53. `jupyter` was renamed to `jupyter-server` in `code-sandboxes` 1.1.1, and the two packages
  54. have to agree on the name.
  55. | Your `jupyter-mcp-server` | Install |
  56. | ------------------------- | -------------------------- |
  57. | **>= 1.5.0** | `code-sandboxes >= 1.1.1` |
  58. | **< 1.5.0** | `code-sandboxes <= 1.0.9` |
  59. ```bash
  60. # On 1.5.0 or later
  61. pip install "jupyter-mcp-server>=1.5.0" "code-sandboxes>=1.1.1"
  62. # Staying on an earlier jupyter-mcp-server
  63. pip install "jupyter-mcp-server<1.5.0" "code-sandboxes<=1.0.9"
  64. ```
  65. An older server with a newer `code-sandboxes` installs cleanly and then fails on the
  66. first execution with `Unknown sandbox variant: jupyter`.
  67. → [**Release notes**](https://jupyter-mcp-server.datalayer.tech/releases)
  68. ---
  69. [![Built on MCP 2 in v2.0.0](https://img.shields.io/badge/%F0%9F%9A%80%20Built%20on%20MCP%202%20in-v2.0.0-1ABC9C?style=for-the-badge&labelColor=0B6E4F)](https://github.com/datalayer/jupyter-mcp-server/releases#release-v2.0.0)
  70. **Jupyter MCP Server 2 runs on the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk) 2**
  71. (`mcp>=2,<3`), the SDK's first major release. Nothing changes in how you start or
  72. configure the server, in the tools, or for the MCP clients connecting to it — the protocol
  73. is negotiated with each client as before. What changes is the Python environment:
  74. | Your `jupyter-mcp-server` | `mcp` SDK |
  75. | ------------------------- | --------- |
  76. | **>= 2.0.0** | `mcp >= 2` |
  77. | **< 2.0.0** | `mcp < 2` |
  78. Both are pinned in the package, so `pip` sorts it out; an environment holding another
  79. package that still pins `mcp<2` has to stay on `jupyter-mcp-server<2` until that package
  80. moves. Writing an extension or a custom token verifier against the SDK? See the
  81. [release notes](https://jupyter-mcp-server.datalayer.tech/releases) for the renamed
  82. imports.
  83. ---
  84. [![Renamed in v1.3.2](https://img.shields.io/badge/%F0%9F%94%84%20Renamed%20in-v1.3.2-D35400?style=for-the-badge&labelColor=7E3F14)](https://github.com/datalayer/jupyter-mcp-server/releases#release-v1.3.2)
  85. **`--provider` is now `--document-provider`** (env var `PROVIDER` → `DOCUMENT_PROVIDER`).
  86. It only ever chose where the notebook **documents** live — `jupyter` for the collaboration
  87. API of a Jupyter Server, `datalayer` for the Datalayer spacer — while the old name and its
  88. help text suggested it also chose where code runs. Execution is picked separately, with
  89. `--sandbox-variant` (`jupyter-server`, `datalayer`, `daytona`, `e2b`, `coreweave`,
  90. `cloudflare`, `kaggle`, `google-colab`, `monty`, `modal`).
  91. Nothing breaks in v1.3.2: `--provider` is still accepted as an alias, `PROVIDER` is still
  92. read, and a `/connect` payload carrying `"provider"` is still understood. Move to the new
  93. names when convenient — the old ones are deprecated, not removed.
  94. ---
  95. <div align="center">
  96. ![Jupyter MCP Server Demo](https://images.datalayer.io/products/jupyter-mcp-server/mcp-demo-multimodal.gif)
  97. </div>
  98. ## 📖 Table of Contents
  99. - [Key Features](#-key-features)
  100. - [MCP Overview](#-mcp-overview)
  101. - [Getting Started](#-getting-started)
  102. - [Sandbox Variants](#-sandbox-variants)
  103. - [Best Practices](#-best-practices)
  104. - [Contributing](#-contributing)
  105. - [Resources](#-resources)
  106. ## 🚀 Key Features
  107. - ⚡ **Real-time control:** Instantly view notebook changes as they happen.
  108. - 🔁 **Smart execution:** Automatically adjusts when a cell run fails thanks to cell output feedback.
  109. - 🧠 **Context-aware:** Understands the entire notebook context for more relevant interactions.
  110. - 📊 **Multimodal support:** Support different output types, including images, plots, and text.
  111. - 📚 **Multi-notebook support:** Seamlessly switch between multiple notebooks.
  112. - 🎨 **JupyterLab integration:** Enhanced UI integration like automatic notebook opening.
  113. - 🤝 **MCP-compatible:** Works with any MCP client, such as Claude Desktop, Cursor, Windsurf, and more.
  114. - 🔍 **Observability:** Built-in hook system with OpenTelemetry integration for tracing tool calls and kernel executions.
  115. Compatible with any Jupyter deployment (local, JupyterHub, ...) and with
  116. [**Datalayer**](https://datalayer.ai) hosted Notebooks, where the Code Sandboxes
  117. come with GPUs and the execution survives a disconnect.
  118. ## 🔧 MCP Overview
  119. ### 🔧 Tools Overview
  120. Every tool, with its parameters, schema and return value, is generated from a live
  121. snapshot of the running server and published at
  122. [**jupyter-mcp-server.datalayer.tech/mcp**](https://jupyter-mcp-server.datalayer.tech/mcp) — so it is never out of step with the
  123. code, which a table copied into this file would be.
  124. They fall into four groups:
  125. - **Server and code sandbox** — browse the Jupyter file system, list kernels, connect to
  126. a server at runtime, and launch, select and terminate code sandboxes.
  127. - **Notebooks** — open, create and switch between notebooks, list them, read one, restart
  128. its kernel, release it.
  129. - **Cells** — read, insert, delete, move, reorder and edit cells, surgically or wholesale,
  130. and clear their outputs.
  131. - **Execution** — run a cell or arbitrary code on the active backend, with multimodal
  132. output and streaming where the sandbox supports it.
  133. Sandbox tools need the optional `jupyter_mcp_sandboxes` extension; see
  134. [Sandbox Variants](#-sandbox-variants).
  135. #### JupyterLab Integration
  136. *Available only when JupyterLab mode is enabled. It is enabled by default.*
  137. In JupyterLab mode the server also exposes JupyterLab commands as MCP tools through
  138. [jupyter-mcp-tools](https://github.com/datalayer/jupyter-mcp-tools) —
  139. `notebook_run-all-cells` and `notebook_get-selected-cell` by default, with more
  140. selectable through `allowed_jupyter_mcp_tools`. The full list and how to configure it are
  141. in the [Additional Tools documentation](https://jupyter-mcp-server.datalayer.tech/operations/tools-jupyterlab).
  142. ### 📝 Prompt Overview
  143. The server implements the MCP
  144. [prompts feature](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts).
  145. `jupyter-cite` cites specific cells from a notebook, the way `@` does in a coding IDE or
  146. CLI. Input parameters and returned content are in the
  147. [Prompts documentation](https://jupyter-mcp-server.datalayer.tech/operations/prompts).
  148. ## 🏁 Getting Started
  149. For comprehensive setup instructions—including `Streamable HTTP` transport, running as a Jupyter Server extension and advanced configuration—check out [our documentation](https://jupyter-mcp-server.datalayer.tech). Or, get started quickly with `JupyterLab` and `STDIO` transport here below.
  150. ### 1. Set Up Your Environment
  151. ```bash
  152. pip install jupyterlab jupyter-collaboration jupyter-mcp-tools ipykernel
  153. ```
  154. ---
  155. ![Tip](https://img.shields.io/badge/%F0%9F%92%A1-Tip-1ABC9C?style=for-the-badge&labelColor=0E7C6B)
  156. To confirm your environment is correctly configured:
  157. 1. Open a notebook in JupyterLab
  158. 1. Type some content in any cell (code or markdown)
  159. 1. Observe the tab indicator: you should see an "×" appear next to the notebook name, indicating unsaved changes
  160. 1. Wait a few seconds—the "×" should automatically change to a "●" without manually saving
  161. This automatic saving behavior confirms that the real-time collaboration features are working properly, which is essential for MCP server integration.
  162. ---
  163. ### 2. Start JupyterLab
  164. ```bash
  165. # Start JupyterLab on port 8888, allowing access from any IP and setting a token
  166. jupyter lab --port 8888 --IdentityProvider.token MY_TOKEN --ip 0.0.0.0
  167. ```
  168. ---
  169. ![Note](https://img.shields.io/badge/%E2%84%B9%EF%B8%8F-Note-3498DB?style=for-the-badge&labelColor=1B5E8A)
  170. If you are running notebooks through JupyterHub instead of JupyterLab as above, refer to our [JupyterHub setup guide](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/jupyterhub).
  171. ---
  172. ### 3. Configure Your Preferred MCP Client
  173. Next, configure your MCP client to connect to the server. We offer two primary methods—choose the one that best fits your needs:
  174. - **📦 Using `uvx` (Recommended for Quick Start):** A lightweight and fast method using `uv`. Ideal for local development and first-time users.
  175. - **🐳 Using `Docker` (Recommended for Production):** A containerized approach that ensures a consistent and isolated environment, perfect for production or complex setups.
  176. <details>
  177. <summary><b>📦 Using uvx (Quick Start)</b></summary>
  178. First, install `uv`:
  179. ```bash
  180. pip install uv
  181. uv --version
  182. # should be 0.6.14 or higher
  183. ```
  184. See more details on [uv installation](https://docs.astral.sh/uv/getting-started/installation/).
  185. Then, configure your client:
  186. ```json
  187. {
  188. "mcpServers": {
  189. "jupyter": {
  190. "command": "uvx",
  191. "args": ["jupyter-mcp-server@latest"],
  192. "env": {
  193. "JUPYTER_URL": "http://localhost:8888",
  194. "JUPYTER_TOKEN": "MY_TOKEN",
  195. "ALLOW_IMG_OUTPUT": "true"
  196. }
  197. }
  198. }
  199. }
  200. ```
  201. </details>
  202. <details>
  203. <summary><b>🐳 Using Docker (Production)</b></summary>
  204. **On macOS and Windows:**
  205. ```json
  206. {
  207. "mcpServers": {
  208. "jupyter": {
  209. "command": "docker",
  210. "args": [
  211. "run", "-i", "--rm",
  212. "-e", "JUPYTER_URL",
  213. "-e", "JUPYTER_TOKEN",
  214. "-e", "ALLOW_IMG_OUTPUT",
  215. "datalayer/jupyter-mcp-server:latest"
  216. ],
  217. "env": {
  218. "JUPYTER_URL": "http://host.docker.internal:8888",
  219. "JUPYTER_TOKEN": "MY_TOKEN",
  220. "ALLOW_IMG_OUTPUT": "true"
  221. }
  222. }
  223. }
  224. }
  225. ```
  226. **On Linux:**
  227. ```json
  228. {
  229. "mcpServers": {
  230. "jupyter": {
  231. "command": "docker",
  232. "args": [
  233. "run", "-i", "--rm",
  234. "-e", "JUPYTER_URL",
  235. "-e", "JUPYTER_TOKEN",
  236. "-e", "ALLOW_IMG_OUTPUT",
  237. "--network=host",
  238. "datalayer/jupyter-mcp-server:latest"
  239. ],
  240. "env": {
  241. "JUPYTER_URL": "http://localhost:8888",
  242. "JUPYTER_TOKEN": "MY_TOKEN",
  243. "ALLOW_IMG_OUTPUT": "true"
  244. }
  245. }
  246. }
  247. }
  248. ```
  249. </details>
  250. ---
  251. ![Tip](https://img.shields.io/badge/%F0%9F%92%A1-Tip-1ABC9C?style=for-the-badge&labelColor=0E7C6B)
  252. 1. **Port Configuration**: Ensure the `port` in your Jupyter URLs matches the one used in the `jupyter lab` command. For simplified config, set this in `JUPYTER_URL`.
  253. 1. **Server Separation**: Use `JUPYTER_URL` when both services are on the same server, or set individual variables for advanced deployments. The different URL variables exist because some deployments separate notebook storage (`DOCUMENT_URL`) from kernel execution (`CODE_SANDBOX_URL`).
  254. 1. **Authentication**: In most cases, document and code sandbox services use the same authentication token. Use `JUPYTER_TOKEN` for simplified config or set `DOCUMENT_TOKEN` and `CODE_SANDBOX_TOKEN` individually for different credentials.
  255. 1. **Notebook Path**: The `DOCUMENT_ID` parameter specifies the path to the notebook the MCP client default to connect. It should be relative to the directory where JupyterLab was started. If you omit `DOCUMENT_ID`, the MCP client can automatically list all available notebooks on the Jupyter server, allowing you to select one interactively via your prompts.
  256. 1. **Image Output**: Set `ALLOW_IMG_OUTPUT` to `false` if your LLM does not support mutimodel understanding.
  257. ---
  258. For detailed instructions on configuring various MCP clients—including [Claude Desktop](https://datalayer.ai/docs/mcp-clients/claude-desktop), [VS Code](https://datalayer.ai/docs/mcp-clients/vscode), [Cursor](https://datalayer.ai/docs/mcp-clients/cursor), [Cline](https://datalayer.ai/docs/mcp-clients/cline), and [Windsurf](https://datalayer.ai/docs/mcp-clients/windsurf) — see [MCP Client Configuration](https://jupyter-mcp-server.datalayer.tech/getting_started#mcp-client-configuration).
  259. ## 🧩 Sandbox Variants
  260. By default, code executes through the `code-sandboxes` `jupyter-server` variant against
  261. a Jupyter Server (`SANDBOX_VARIANT=jupyter-server`). Setting `SANDBOX_VARIANT` to any
  262. other value uses another [code-sandboxes](https://github.com/datalayer/code-sandboxes)
  263. engine via the sandbox's plain kernel client when the selected variant exposes
  264. one, so the same notebook tools can run code on additional backends.
  265. The spelling is not fussy: `google_colab`, `google-colab` and `GOOGLE-COLAB` all name the
  266. same variant. The names below are the canonical ones.
  267. Sandbox features are provided by the optional `jupyter_mcp_sandboxes` extension.
  268. To expose sandbox lifecycle tools (`launch_sandbox`, `list_sandboxes`,
  269. `use_sandbox`, `terminate_sandbox`) or run any non-`jupyter-server` sandbox variant,
  270. install it with `pip install jupyter_mcp_sandboxes`.
  271. | Engine | `SANDBOX_VARIANT` | Extra install | Key variables | Docs |
  272. | ------ | ----------------- | ------------- | ------------- | ---- |
  273. | Jupyter Server (default) | `jupyter-server` | — | `JUPYTER_URL`, `JUPYTER_TOKEN` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/jupyter-server) |
  274. | JupyterHub | `jupyter-server` | — | `CODE_SANDBOX_URL`, `CODE_SANDBOX_TOKEN` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/jupyterhub) |
  275. | Datalayer | `datalayer` | `jupyter-mcp-server[datalayer]` | `CODE_SANDBOX_URL`, `CODE_SANDBOX_TOKEN`, `SANDBOX_ENVIRONMENT` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/datalayer) |
  276. | Kaggle | `kaggle` | `jupyter-mcp-server[kaggle]` | Kaggle credentials, or `CODE_SANDBOX_URL` for interactive mode | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/kaggle) |
  277. | Google Colab | `google-colab` | `jupyter-mcp-server` | `CODE_SANDBOX_URL`, `CODE_SANDBOX_ID`, `CODE_SANDBOX_PROXY_TOKEN` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/google-colab) |
  278. | Monty | `monty` | `jupyter-mcp-server[monty]` | — | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/monty) |
  279. | Modal | `modal` | `jupyter-mcp-server[modal]` | Modal credentials | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/modal) |
  280. | Daytona | `daytona` | `jupyter-mcp-server[daytona]` | `DAYTONA_API_KEY`, or `DAYTONA_JWT_TOKEN` + `DAYTONA_ORGANIZATION_ID` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/daytona) |
  281. | E2B | `e2b` | `jupyter-mcp-server[e2b]` | `E2B_API_KEY` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/e2b) |
  282. | CoreWeave | `coreweave` | `jupyter-mcp-server[coreweave]` | `CWSANDBOX_API_KEY` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/coreweave) |
  283. | Cloudflare | `cloudflare` | `jupyter-mcp-server[cloudflare]` | `CLOUDFLARE_SANDBOX_API_URL`, `CLOUDFLARE_SANDBOX_API_KEY` | [Setup](https://jupyter-mcp-server.datalayer.tech/code-sandboxes/cloudflare) |
  284. Each engine has its own page with the credentials it needs, the accelerator options it
  285. accepts and a worked client configuration — start from
  286. [**jupyter-mcp-server.datalayer.tech/code-sandboxes**](https://jupyter-mcp-server.datalayer.tech/code-sandboxes).
  287. ## 🧪 Testing
  288. Run the test suite:
  289. ```bash
  290. pytest tests/
  291. ```
  292. Required environment variables for tests:
  293. - None for the default local suite.
  294. Optional environment variables:
  295. - `TEST_MCP_SERVER`: `true`/`false` toggle for standalone MCP server mode tests (default `true`).
  296. - `TEST_JUPYTER_SERVER`: `true`/`false` toggle for Jupyter extension mode tests (default `true`).
  297. - `DATALAYER_API_KEY`: required only for Datalayer cloud smoke/integration tests.
  298. - `DATALAYER_RUN_URL`: optional custom Datalayer code sandbox URL for datalayer engine tests.
  299. - `SANDBOX_ENVIRONMENT`: optional cloud environment override (for example `ai-agents-env`).
  300. ## ✅ Best Practices
  301. - Interact with LLMs that supports multimodal input (like Gemini 2.5 Pro) to fully utilize advanced multimodal understanding capabilities.
  302. - Use a MCP client that supports returning image data and can parse it (like Cursor, Gemini CLI, etc.), as some clients may not support this feature.
  303. - Break down complex task (like the whole data science workflow) into multiple sub-tasks (like data cleaning, feature engineering, model training, model evaluation, etc.) and execute them step-by-step.
  304. - Provide clearly structured prompts and rules (👉 Visit our [Prompt Templates](extensions/prompt-templates/README.md) to get started)
  305. - Provide as much context as possible (like already installed packages, field explanations for existing datasets, current working directory, detailed task requirements, etc.).
  306. ## 🤝 Contributing
  307. We welcome contributions of all kinds! Here are some examples:
  308. - 🐛 Bug fixes
  309. - 📝 Improvements to existing features
  310. - 🔧 New feature development
  311. - 📚 Documentation improvements and prompt templates
  312. For detailed instructions on how to get started with development and submit your contributions, please see our [**Contributing Guide**](CONTRIBUTING.md).
  313. ### Our Contributors
  314. [![Contributors](https://contrib.rocks/image?repo=datalayer/jupyter-mcp-server)](https://github.com/datalayer/jupyter-mcp-server/graphs/contributors)
  315. ## 📚 Resources
  316. Looking for blog posts, videos, or other materials about Jupyter MCP Server?
  317. 👉 Visit the [**Resources section**](https://jupyter-mcp-server.datalayer.tech/resources) in our documentation for more!
  318. ---
  319. <div align="center">
  320. **If this project is helpful to you, please give us a ⭐️**
  321. Made with ❤️ by [Datalayer](https://datalayer.ai)
  322. <img src="https://assets.datalayer.tech/datalayer-25.svg" alt="Datalayer Logo" width="200"/>
  323. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.