Notebook Intelligence brings Claude Code and Copilot inside JupyterLab
A JupyterLab extension supporting Claude Code, Copilot, Ollama, and OpenAI-compatible LLMs, with MCP, skills, plugins, and notebook agents.
At a glance
- What is it?
- A JupyterLab extension that adds chat, inline edit and auto-complete on top of Copilot, OpenAI-compatible endpoints, Ollama or the Claude Code CLI, with MCP, rulesets and skills wired in.
- Who is it for?
- Notebook Intelligence fits JupyterLab users who want serious assistant features without leaving notebooks, and teams already invested in Claude Code skills, MCP servers or rulesets that should keep working inside JupyterLab. Skip it if you need a permissive licence for redistribution, if you live in VS Code notebooks rather than JupyterLab, or if your provider needs a dedicated adapter that is not in the four.
- Can I use it commercially?
- Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
JupyterLab gets an assistant that knows your stack
JupyterLab users have watched AI assistance arrive everywhere else: the terminal, the editor, the browser. Notebook Intelligence, NBI for short, closes that gap as an extension that adds a chat panel, inline cell editing and auto-complete directly to JupyterLab 4.x. What distinguishes it is the provider breadth: GitHub Copilot, any OpenAI-compatible endpoint, any LiteLLM-compatible endpoint, local models through Ollama, and, unusually, Anthropic's Claude via the Claude Code CLI.
NBI is free and open source under GPL-3.0, with provider charges flowing to whichever provider you connect. The audience is the working data scientist or researcher living in notebooks who wants assistant features without leaving the kernel-aware environment, plus teams that want the AI behavior configurable as code rather than baked into a hosted product.
Installing and the first chat
The requirements list is short: Python 3.10 or newer, JupyterLab 4.x, and Node.js only if you plan to use Claude mode or MCP servers that launch through npx. The README recommends a fresh virtualenv or conda environment so the extension stays clear of system Python.
pip install notebook-intelligence
jupyter labThe comment matters: restart JupyterLab if it was already running. After restart, the setup is four steps in prose: click the NBI icon in the left sidebar, open NBI Settings from the gear icon, sign into your provider, either a Copilot sign-in flow, a pasted API key for OpenAI or LiteLLM endpoints, or a pointer at your local Ollama daemon, and type a message. A troubleshooting document exists for the panel-stays-empty case, which is the classic first-run failure of server extensions.
Four providers, and a CLI route to Claude
The concepts section is the honest map of the architecture. Four provider adapters ship built in: GitHub Copilot, OpenAI-compatible, LiteLLM-compatible and Ollama. Claude is deliberately not a fifth adapter. In default mode, whichever provider you configured handles chat, inline chat and auto-complete.
Claude mode is the exception, and the README is precise about its two halves. The chat panel is driven by shelling out to the Claude Code CLI, which means the panel inherits that CLI's tools, skills, MCP servers and custom commands. Inline chat and auto-complete, meanwhile, call Claude models directly through the Anthropic API, because completion-latency work does not fit a CLI round trip. The glossary also defines chat participants, the mentionable personas such as @workspace and @mcp that route a request to a specific tool surface, and rulesets, markdown files under ~/.jupyter/nbi/rules/ injected into the system prompt to enforce team conventions.
Claude mode: the CLI inside the IDE
The Claude mode settings go beyond an on-off toggle. You pick the chat model and the auto-complete model separately, choose whether agent settings come from the user level, the project level, or both, and decide which tool sets activate: Claude Code's own tools are always on, and NBI contributes its own Jupyter UI tools for authoring notebooks and running cells. API key and base URL fields let the inline features point at Anthropic or a self-hosted endpoint.
Two details reveal the engineering care. Model defaults resolve against the model list fetched from your configured endpoint rather than a hardcoded ID, and if a configured ID vanishes, NBI falls back within the same tier by version, so a stale claude-sonnet reference keeps working. And the usage footer shows a dollar figure only when NBI runs against a direct Anthropic API key on Anthropic's endpoint: the SDK prices from the CLI's public list rates, which are not the marginal cost on a subscription login, so the extension omits a number it cannot stand behind. That is honest accounting in a market that mostly fakes it.
The extension surface: MCP, rulesets, skills, plugins
NBI treats the current agent-ecosystem standards as first-class citizens rather than afterthoughts. MCP support lets the model call external tools, with a config example in the README covering servers that run as separate processes or through npx. Rulesets inject conventions into the system prompt from a well-known directory. Claude Skills, the directories holding a SKILL.md plus helpers under .claude/skills/, are invocable inside sessions, and Claude plugins installed through a marketplace run within Claude Code sessions that NBI hosts.
The glossary draws the distinctions most documentation blurs: a skill is workspace-scoped and file-based, a plugin is packaged and marketplace-distributed, and NBI's own JupyterLab extension is a separate artifact from any of them. For teams standardizing on Claude Code, this means the investment in skills and MCP servers keeps paying inside notebooks, which is NBI's sharpest differentiator.
Project health and the GPL question
The repository is maintained at a pace that matters for an extension chasing moving targets: the last push was on 2026-09-15, three releases are published, and the tree carries benchmarks, docs, a changelog, PRIVACY.md and SECURITY.md. Feature breadth is real: cell output actions, notebook toolbar generation, multi-language kernel-aware notebooks, automatic reload of files changed on disk, configuration readiness checks and performance diagnostics each have their own README section.
The licence deserves a deliberate look before adoption. GPL-3.0 for a JupyterLab extension is unremarkable for end users and researchers, but teams that embed or redistribute Jupyter distributions commercially should read the terms with their own counsel. The dual Node and Python packaging, visible in the tree's package.json, pyproject.toml and setup.py, is the standard shape for a prebuilt JupyterLab extension, not a red flag.
Against Jupyter AI and plain Claude Code
The comparison people actually search is Jupyter AI, the official Jupyter extension for chat with many providers. The overlapping ground is real: both put a chat panel in the sidebar and both speak to multiple backends. NBI's bet is depth on the Claude Code integration and the surrounding standards, MCP servers, skills, plugins, rulesets, plus inline completion and an agent that drives notebooks, where Jupyter AI stays closer to a general chat facade.
The other alternative is skipping the notebook integration entirely and running the Claude Code CLI beside JupyterLab. That works and inherits everything Claude mode offers, but it loses the native integration points: inline edits in cells, kernel-aware behavior, and auto-complete typed into the notebook itself. For light use, the CLI alone is simpler; for daily notebook work, the integration is the product.
Editorial conclusion
Notebook Intelligence fits JupyterLab users who want serious assistant features without leaving notebooks, and teams already invested in Claude Code skills, MCP servers or rulesets that should keep working inside JupyterLab. Skip it if you need a permissive licence for redistribution, if you live in VS Code notebooks rather than JupyterLab, or if your provider needs a dedicated adapter that is not in the four. Verify the fit quickly: pip install it in a scratch environment, connect your cheapest provider, and check that inline completion latency in a real notebook is something you can live with.
Frequently asked questions
Does Notebook Intelligence work with local models?
Yes. Ollama is one of the four built-in provider adapters, pointed at your local daemon, and OpenAI-compatible or LiteLLM-compatible endpoints cover self-hosted servers as well.
What is Claude mode in Notebook Intelligence?
A mode where the chat panel is driven by the Claude Code CLI, inheriting its tools, skills and MCP servers, while inline chat and auto-complete call Claude models through the Anthropic API. It requires the Claude Code CLI on PATH.
What do I need to run Notebook Intelligence?
Python 3.10 or newer and JupyterLab 4.x, installed with pip install notebook-intelligence. Node.js is only required for Claude mode and for MCP servers that launch via npx.
Community notes