Jupyter Blog - AI

A User’s Journey with Plugin Playground: From First Idea to Installable JupyterLab Extension.

2026-05-28T17:45:00+00:00

We are excited to announce the 1.0 release of JupyterLab Plugin Playground, allowing you to seamlessly experiment with the creation of Jupyter Notebook and JupyterLab plugins to add any functionality you may desire. To install:

pip install jupyterlab-plugin-playground

or use it from Binder or JupyterLite without installing anything by clicking one of these links: Binder (Lab), Binder (Notebook v7), JupyterLite (Lab), JupyterLite (Notebook v7).

Motivation

Building a JupyterLab extension has traditionally required setting up a complex local environment: installing dependencies from disjoint ecosystems (Node.js and Python), configuring tooling, and hunting down the right documentation. The goal of the Playground is to eliminate that setup overhead and streamline extension development. By bringing the runtime, documentation, and the context required for extension development into a single browser tab, you can go from idea to working extension without any local setup required.

Journey At a Glance

Start with a tiny extension idea that is easy to verify visually.
Choose a build path: Manual or AI-assisted.
Load and iterate inside JupyterLab until behavior is stable.
Build a second extension to prove the workflow is repeatable.
Share plugin files/packages for product and engineering review.
Export as a wheel(.whl) and validate installation in a clean Binder runtime.
Export as a zip and move the scaffold into a normal GitHub repository.

1.0: Pick Your Starting Path

At the beginning, choose the path that matches your confidence level and speed needs. If this is your first time with Plugin Playground, you can optionally run Take the Tour from the Launcher or Command Palette for quick orientation before starting.

Start from File If you already know the APIs you need and want direct control.
Build with AI If you know the intended behavior but want a first draft quickly.

Both paths converge to the same shipping workflow later.

2.0: Build Extension #1 Manually

For the first pass, we will create something small and observable.

Our Goal: add a command named Toggle Right Sidebar to the command palette.

2.1: Create the plugin file

Launch Start from File. This comes with a dummy template.

import {
  JupyterFrontEnd,
  JupyterFrontEndPlugin,
} from '@jupyterlab/application';

const plugin: JupyterFrontEndPlugin<void> = {
  id: 'hello-world:plugin',
  autoStart: true,
  activate: (app: JupyterFrontEnd) => {

  },
};

export default plugin;

Now build the plugin in order:

In Tokenssection in the right sidebar, search ICommandPalette and click insert ( + icon ), so Plugin Playground adds token import and dependency wiring.
Add a simple command skeleton inside the activate function:

const commandID = 'my-first-playground-plugin:toggle-sidebar'; 
app.commands.addCommand(commandID, { label: 'Toggle Right Sidebar', 
  execute: async () => {
      // place cursor here
  } 
});

In Commands, search application:toggle-right-area, place your cursor inside execute of the added command ( see above ) and use Insert in selection This adds at the cursor position:

app.commands.execute('application:toggle-right-area');

commandPalette.addItem({ command: commandID, category: 'AAA' });

After those edits, your file should look like:

import { ICommandPalette } from '@jupyterlab/apputils';
import {
  JupyterFrontEnd,
  JupyterFrontEndPlugin,
} from '@jupyterlab/application';

const plugin: JupyterFrontEndPlugin<void> = {
  id: 'hello-world:plugin',
  autoStart: true,
  requires: [ICommandPalette],
  activate: (app: JupyterFrontEnd, commandPalette: ICommandPalette) => {
    const commandID = 'my-first-playground-plugin:toggle-sidebar'; 
    app.commands.addCommand(commandID, { label: 'Toggle Right Sidebar', 
      execute: async () => {
          app.commands.execute('application:toggle-right-area');
      } 
    });
      commandPalette.addItem({ command: commandID, category: 'AAA' });
  },
};

export default plugin;

Uses the typed plugin template (JupyterFrontEndPlugin<void>) and typed activate parameters. Imports ICommandPalette so the plugin can add entries to the Command Palette.
Registers a new command (my-first-playground-plugin:toggle-sidebar) and executes application:toggle-right-area when your command runs.
Adds your command to the palette under the category AAA.

2.3: Load it and verify behavior

Click Load Current File As Extension or click the run button in the toolbar, and open Command Palette.

When you run Load Current File As Extension, Plugin Playground compiles the active file and registers the plugin object into the live JupyterLab session. During iteration, if a plugin with the same id already exists, Plugin Playground attempts to deactivate and replace it so reload loops stay fast.

Expected result:

Toggle Right Sidebar appears in the command palette ( open command palette by going through view -> Activate command palette or Press Accel + shift + C).

Running it hides/shows the JupyterLab right sidebar.

3.0: Build with AI

If you want a faster draft, use AI assistance for the same extension workflow.

Goal: add the Show Active Notebook Cell Count command with a friendly no-notebook fallback.

3.1: Give AI a precise request

Use Build with AI and give a prompt:

for example, something like:-

Create a JupyterLab plugin named "active-notebook-cell-counter".
Add a command "Show Active Notebook Cell Count".
If no notebook is active, show a friendly dialog message.
If a notebook is active, show the current cell count in a dialog.
Register the command in the command palette under category "Playground Demo".
Export default plugin object.

What this block does:

This gives AI a concrete plugin goal, command name, and fallback behavior requirements.

3.2: Use AI + deterministic inserts together

In the Commands tab:

Insert in selection for predictable boilerplate insertion.
Prompt AI to insert when placement context is tricky.
{n} when you need argument shape clarity ( Inspect the command signature before insertion: it shows expected argument names/types and return details).

Use Insert in selection for predictable snippets, and switch to AI when insertion location or code adaptation depends on the surrounding context.

4.0: Iterate Faster Before Handoff

Once the extensions run, enable Run on save(from the toolbar or from the settings) while polishing labels, command categories, and small behaviour details.

With Run on save, each file save triggers a reload loop for that plugin file, which makes label tweaks, command grouping changes, and message-copy iteration much faster than manual reload cycles. And with enabling the global setting (Load as extension on save), this behaviour is present for all files by default.

Before packaging, you can ask a teammate to review behaviour or just share links for the extension for a quick look using:

Share a single file when sharing is about one plugin file.
Share a package when your logic spans several files.

This keeps review lightweight: collaborators can inspect and discuss behaviour before you commit to repository structure, CI, and release wiring.

6.0: Export as Wheel and Validate in Binder

Now test as an installable artifact in a separate environment.

6.1: Export `.whl`

From the export dropdown ( in toolbar ), choose Export as Python package (.whl).

6.2: Install in Binder

Open JupyterLab on Binder.
Upload the downloaded wheel.
Open a terminal and run:

python -m pip install - force-reinstall ./your_exported_package.whl

What this block does:

Installs the wheel you just exported from Plugin Playground into Binder. (Uses — force-reinstall so Binder replaces any previously installed copy with your newest build). Then refresh JupyterLab and verify commands.

7.0: Export as Zip and Create a GitHub Repository

After runtime validation, move to normal engineering workflows.

7.1: Export `.zip`

Choose **Export as archive (.zip)** from the toolbar export dropdown.

7.2: Bootstrap repository

Unzip locally, create an empty GitHub repo, then run:

git init
git add .
git commit -m "Initial extension scaffold from Plugin Playground"
git branch -M main
git remote add origin https://github.com/<your-org-or-user>/my-jlab-extension.git
git push -u origin main

What this block does:

Initializes a new Git repository from the exported scaffold and creates an initial commit that captures the generated extension baseline.

Now your prototype is in a standard repo flow with PRs, CI, and release automation.

What’s Next

Plugin Playground is still evolving. We’re actively working on the LSP integration for JupyterLite to bring code intelligence autocomplete and diagnostics directly into the editor, an “Ask AI” button on log errors that lets you send error context directly into the AI chat for instant debugging help. In the future, we would like to explore git integration to snapshots every successful load, paired with a built-in diff viewer to compare any snapshot against your current file. If you have any suggestions or encounter any problems, please let us know by opening an issue on GitHub.

Acknowledgements

We are grateful to the Jupyter Foundation and its members for sponsoring the development of Plugin Playground as part of Community Funding Proposals 2025.

We thank Jeremy Tuloup, Nick Bollweg, and Nicolas Brichet for providing inspiration, review, and advice across our work on the plugin and its dependencies. Finally, this work would not be possible without the authors of earlier iterations of Plugin Playground.

About the Developers

Anuj Singh is an OSS intern at OpenTeams. Anuj implemented Plugin Playground v1.0.0 and contributed to its dependencies during his internship at OpenTeams.

Smera Goel is a UI/UX designer at Quansight. Smera contributed to the user experience and design direction of Plugin Playground.

Michał Krassowski is a Senior Software Engineer at OpenTeams. Mike provided guidance and direction for the development of the Plugin Playground.

nb-cli: A Command-Line Interface for AI Agents and Notebook Automation

2026-05-11T19:04:00+00:00

The rise of AI coding agents has transformed how we think about developer tools. Large language models like Claude, GPT, and others are remarkably effective at using command-line interfaces — they’ve been trained on billions of lines of CLI usage from documentation, Stack Overflow, and GitHub. But when it comes to working with Jupyter notebooks programmatically, there’s been a gap: existing tools focus on running agents within notebooks, but what about agents that need to work with notebooks as artifacts?

nb-cli, an experimental open-source command-line interface designed specifically for AI agents, automation scripts, and developers who need programmatic access to Jupyter notebooks. Built with Rust for performance and reliability, nb-cli provides a fast, composable way to read, write, execute, and manipulate notebooks through a clean command line interface that follows the nbformat specification.

The Problem: Notebooks as Black Boxes

While Jupyter notebooks are indispensable for interactive exploration, their underlying .ipynb JSON structure has long been a friction point for programmatic interaction, especially for shell scripts and Large Language Models (LLMs).

Traditional workflows often break down when automation or AI-driven analysis is required. Consider the following scenarios where standard notebook interfaces prove insufficient:

Autonomous Analysis: An AI agent tasked with auditing a data science workflow must programmatically inspect individual cells to map out the analysis pipeline.
Automated Validation: CI/CD systems require a reliable method to execute notebooks, validate outputs, and catch errors before deployment.
Documentation at Scale: Developers need tools to automatically transform notebook content into clean, accessible documentation.
Production Debugging: Teams need a way to troubleshoot notebook execution failures in headless production environments without manual intervention.
Notebooks as Data: Analysts may want to treat a notebook as a structured database to programmatically generate business reports, research summaries, or custom visualizations.

Historically, solving these problems required labor-intensive workarounds like manually navigating the JupyterLab UI, writing brittle Python scripts to parse complex JSON files, or using execution tools that lack real-time integration.

nb-cli bridges this gap by offering a CLI-first interface designed for the modern era of automation. By leveraging command-line patterns and Unix composability, it provides the structured output and predictable interface that AI agents and developers need to treat notebooks as first-class citizens in any software stack.

Key Features

Works With or Without a Jupyter Server

nb-cli doesn’t require a running Jupyter server. By default, it reads and writes .ipynb files directly and communicates with kernels over ZeroMQ for execution. This makes it well-suited for scripting, CI pipelines, and any workflow where launching a server is unnecessary overhead.

# Create a notebook — no server needed
nb create analysis.ipynb

# Add cells
nb cell add analysis.ipynb --source "import pandas as pd"
nb cell add analysis.ipynb --source "# Data Analysis" --type markdown

# Execute
nb execute analysis.ipynb

# Read back with outputs
nb read analysis.ipynb

Connecting to a server becomes valuable if multiple users and/or agents are editing the same notebook simultaneously within a JupyterLab session. Once connected, nb-cli uses Y.js, the same CRDT protocol JupyterLab uses internally for conflict-free real-time synchronization.

# Auto-detect and connect to local Jupyter server
nb connect

# Or, connect to a specific server
nb connect --server http://localhost:9999 --token abc

# Add a cell - it appears instantly in JupyterLab
nb cell add experiment.ipynb --source "df.head()"

# Execute via the remote kernel
nb execute experiment.ipynb --cell fe456

# Restart the kernel before execution for reproducibility checks
nb execute experiment.ipynb --restart-kernel

# Disconnect
nb disconnect

When connected to a Jupyter server, nb-cli detects whether a notebook is open in JupyterLab and uses server APIs for conflict-free collaborative editing. If the notebook isn’t open, it seamlessly falls back to file-based operations.

AI-Optimized Markdown Format

Language models don’t parse JSON, they predict tokens. This distinction matters more than you’d think when you’re building a tool that feeds notebook content into an LLM’s context window. Jupyter’s native notebook format is deeply nested JSON. Source code is stored as arrays of strings. Outputs carry base64-encoded blobs. Metadata nests several levels deep. This is fine for a JSON parser, but for a language model working within a fixed context window, 30–40% of those tokens are structural characters — braces, brackets, escaped newlines that carry no semantic value. Another common option is plain Markdown which is token-efficient and human-readable, but it’s ambiguous. A # could be a markdown heading or a Python comment. A fenced code block could be a notebook cell or an example inside a markdown cell’s documentation. When an LLM is asked to “fix the error in cell 7,” it needs to reliably locate that cell in the text and plain markdown gives it no structural markers to count on, just a sequence of code fences that all look the same.

So we designed a line-oriented sentinel format:

@@notebook {"format":"ai-notebook","metadata":{"kernelspec":{"name":"python3"}}}

@@cell {"index":0,"id":"f68t57","cell_type":"code","execution_count":1}
```python
df.head()
```
@@output {"output_type":"execute_result"}
```text
   col_a  col_b
0      1      a
```

The format makes a few deliberate tradeoffs. @@cell and @@output sentinels give the model unambiguous structural boundaries without counting braces or tracking nesting. Inline JSON metadata on each sentinel line places cell type, index, and execution count in the tokens immediately before the content — matching how attention mechanisms locate information. Code in fenced blocks with language hints activates the model’s syntax-level training. And because each cell block is self-contained, truncation degrades gracefully — unlike JSON, where a cut anywhere breaks the entire structure.

Designed for Composability

nb-cli follows Unix conventions — plain text output, stdin support, predictable exit codes — so it composes naturally with other CLI tools. For AI agents, this matters because a single shell command can replace what would otherwise be multiple tool calls with intermediate parsing.

Consider an agent asked to “add a summary section to the notebook and run it.” Without nb-cli, this requires separate API calls to read the notebook, parse the structure, insert a cell, write the file, find a kernel, execute, read back the output — each consuming tokens for the request and response. With nb-cli:

nb cell add analysis.ipynb --source "$(cat <<'EOF'                                                                         
@@markdown                                                                                                                 
# Summary                                                                                                                  
                                                                                                                            
@@code                                                                                                                     
print(f"Rows: {len(df)}, Columns: {len(df.columns)}")                                                                      
df.describe()                                                                                                              
EOF                                                                                                                        
)" && nb execute analysis.ipynb -i -2 -i -1 && nb read analysis.ipynb -i -1

Three operations — add cells, execute them, read the result — in a single shell invocation. The agent gets back only the output it needs without re-reading the entire notebook.

The same principle applies to debugging. An agent investigating a failed notebook doesn’t need to read every cell to find the problem.

# Find cells with errors — returns only the relevant cells                                                                 
nb search analysis.ipynb --with-errors

One call, targeted output, no wasted tokens on cells that ran successfully.

Stable Cell Referencing

nb-cli supports two ways to reference cells.

Index-based:--cell-index 0 (supports negative indexing: -1 = last cell)
ID-based: --cell f68t57 (doesn’t change when cells move)

# Reference by position
nb cell update analysis.ipynb --cell-index 0 --source "x = 42"

# Reference by stable ID — safe even after cells are reordered
nb cell update analysis.ipynb --cell ce456 --source "print('Done')"

# Execute the last cell
nb execute analysis.ipynb --cell-index -1

Powerful Search Capabilities

nb-cli includes built-in search to quickly locate cells by content, type, or execution errors. By default, search matches against cell source code, but a scope filter extends it to execution outputs.

# Search for cells containing a pattern  
nb search analysis.ipynb "import pandas"
                      
# Find all cells with execution errors
nb search analysis.ipynb --with-errors                                                                                                     

# Search within outputs instead of source                                                                                       
nb search analysis.ipynb "KeyError" --scope output

# Filter by cell type
nb search analysis.ipynb "TODO" --cell-type mardown

For AI agents, — with-errors is particularly useful — instead of reading an entire notebook to find what failed, the agent gets back only the cells that need attention. Combined with — scope output, it can search error tracebacks directly without parsing every cell’s results. The same capabilities are useful for humans auditing notebooks for deprecated APIs, locating specific functions across large notebooks, or extracting patterns before a refactor.

Multi-Cell Operations

One of the most common patterns when working with notebooks programmatically is adding a sequence of cells — a markdown header, then setup code, then analysis. Doing this one cell at a time means multiple round-trips and index bookkeeping. Instead, nb-cli accepts multiple cells in a single call using the sentinels format we saw earlier.

# Add a markdown header followed by a code cell in one command
nb cell add report.ipynb --source "$(cat <<'EOF'
@@markdown
# Results

@@code
import pandas as pd
df = pd.read_csv('results.csv')
df.head()
EOF
)"

For more control, sentinels also accept the full @@cell {“cell_type”: “…”} JSON format.

nb cell add report.ipynb --source "$(cat <<'EOF'                                     
@@cell {"cell_type": "markdown"}                                                     
# Analysis Header                                                                     

@@cell {"cell_type": "code"}                                                         
print("hello")
EOF                                                                
)"

Both formats work with stdin, making it easy to compose cells from scripts or pipelines.

printf '@@markdown\n## Summary\n\n@@code\ndf.describe()\n' | nb cell add report.ipynb --source -

The same batching philosophy extends to execution and deletion:

# Execute cells 2 through 5
nb execute analysis.ipynb --start 2 --end 5

# Delete specific cells
nb cell delete analysis.ipynb -i 0 -i 2

# Delete a range of cells
nb cell delete analysis.ipynb --range 0:3

Environment-Aware Execution

— uv and — pixi flags are supported on nb connect, nb execute, and nb create, telling nb to discover Jupyter servers and kernels through the appropriate environment manager. nb status — python returns the command prefix needed to run Python in the same environment as the connected kernel — useful when agent-generated shell commands need to match the active notebook environment.

# Connect using a uv-managed environment
nb connect --uv

# Execute in a pixi-managed environment
nb execute analysis.ipynb --pixi

# Get the Python prefix for agent-generated shell commands
nb status --python
# Returns: "uv run", "pixi run", or empty for system Python

# Use in a pipeline
$(nb status --python) python -c "import pandas; print(pandas.__version__)"

Real World Use Cases

AI Agent Workflows

AI coding agents can now manipulate notebooks as a part of their analysis workflow.

# Surface all failing cells
nb search data_analysis.ipynb --with-errors

# Apply the fix
nb cell update data_analysis.ipynb --cell-index 3 --source "df = pd.read_csv('data.csv', encoding='utf-8')"

# Re-execute to verify
nb execute data_analysis.ipynb --cell-index 3

CI/CD Integration

Automated testing and validation of notebooks in continuous integration pipelines.

echo "Executing notebook..."
nb execute pipeline.ipynb --allow-errors

echo "Checking for errors..."
if nb search pipeline.ipynb --with-errors; then
  echo "Notebook execution failed"
  exit 1
fi

echo "Clearing outputs before commit..."
nb output clear pipeline.ipynb

echo "✓ All cells executed successfully"

Programmatic Notebook Generation

Generate documentation, reports, and analysis automatically.

# Create a report notebook
nb create report.ipynb

# Add title, introduction, and analysis in one multi-cell command
nb cell add report.ipynb --source "$(cat <<'EOF'
@@markdown
# Monthly Sales Report

@@markdown
Generated on $(date)

@@code
import pandas as pd
df = pd.read_csv('sales_data.csv')
df.describe()
EOF
)"

# Execute to populate outputs
nb execute report.ipynb

Debugging Production Notebooks

Quickly inspect and diagnose issues in deployed notebooks.

# Find all cells with errors
nb search failing_notebook.ipynb --with-errors

# Search for cells with deprecated API usage
nb search analysis.ipynb "pandas.np"

# Find cells with potential security issues
nb search notebook.ipynb "eval("

# Examine specific failing cell with full output
nb read failing_notebook.ipynb --cell-index 5

# Restart kernel and re-run for clean reproducibility check
nb execute failing_notebook.ipynb --restart-kernel

nb-cli in Action

To illustrate how AI agents use nb-cli naturally, here are some examples of agent interactions.

Example 1: Claude creating a RL for LLMs notebook

User Prompt: Help me learn about reinforcement learning for LLMs by creating a notebook and explaining at each cell how it all works. Cover the key concepts: policy model, reward model, KL divergence penalty, PPO, and GRPO. Use a tiny toy model (small vocab, GRU-based) so everything runs on CPU without any API keys.

Example 2: Codex fixing multiple bugs in a notebook

User Prompt: The file churn_analysis.ipynb is a broken research notebook that was last updated in 2023. Fix it so it runs cleanly end-to-end. Identify every cell that fails, fix each issue and verify the notebook executes successfully. After fixing, add a brief markdown note above each cell you changed explaining what was broken and why.

Codex fixed four bugs in churn_analysis.ipynb: a hardcoded file path, DataFrame.append() (removed in pandas 2.0), sklearn.cross_validation (removed in sklearn 0.20), and plot_confusion_matrix (removed in sklearn 1.2) and verified the notebook runs end-to-end after these chages.

Getting Started with nb-cli

Installation

Use the install script.

curl -fsSL https://raw.githubusercontent.com/jupyter-ai-contrib/nb-cli/main/install.sh | bash

If your platform is not supported, and you get an error during install, use cargo to install.

cargo install nb-cli

Or build from source.

git clone https://github.com/jupyter-ai-contrib/nb-cli.git
cd nb-cli
cargo build --release

The binary will be available at target/release/nb .

To enable your AI agents to use nb for all notebook operations, install the skill.

npx skills install jupyter-ai-contrib/nb-cli

About the developers

Andrii Ieroshenko is a Software Development Engineer at AWS. He is a long term contributor to project Jupyter working on JupyterLab, Jupyter AI and several other projects. He is also a member of the Jupyter Media Strategy Working Group.

Brian Granger is a Senior Principal Technologist at AWS. Brian is a cofounder of Project Jupyter, a board member of the Jupyter and PyTorch Foundations.

Piyush Jain is a Principal Engineer at AWS working on Jupyter and Agentic AI. He is a distinguished Jupyter contributor and a member of the Jupyter Server Council.

How can you help?

We’re just getting started with nb-cli. Please join us!.

Install and use the nb-cli. If you find any bugs or have suggestions, please create issues on GitHub.
Join the discussion about nb-cli, open issues or add to discussion in jupyter-ai-contrib.
Contribute: Your bug reports, feature requests, and pull requests will help improve this project for everyone.

JupyterLab 4.5 and Notebook 7.5 are available!

2025-11-24T09:32:00+00:00

JupyterLab 4.5 has been released! This new minor release of JupyterLab includes 51 new features and enhancements, 81 bug fixes, 44 maintenance tasks and 38 documentation improvements. There were 51 contributors to this release.

Jupyter Notebook 7.5 has also been released, including many of the fixes and enhancements in this JupyterLab 4.5 release. While the releases on GitHub provide additional detail on the updates made to both JupyterLab 4.5 and Notebook 7.5, this article highlights some particularly notable changes.

Extension authors can refer to the Extension Migration Guide for information on API updates and details regarding changes to core packages.

Performance and windowing

The default windowing mode is now contentVisibility which improves cell rendering and alleviates previously reported issues. The minimap can be enabled for all windowing modes and all notebooks via the Settings menu, or by toggling the minimap per notebook with the View -> Show Minimap option. Additional fixes improve layout containment and scrollbar behavior when working with long cells.

Notebook improvements

Saving large notebooks is now faster and more responsive thanks to streamed uploads and users can now open notebooks without starting a kernel, via the Open With context menu option.

Open a notebook without a kernel

Markdown support has been expanded for using grid and flex based layouts and the Table of Contents has been significantly improved to better handle markdown headings, fixing issues with HTML tags, comments, and horizontal lines.

Copying and pasting cells across browser tabs is now supported and the “Line Wrap” toggle in settings now correctly applies line wrapping to cells.

Other improvements include: restored scrolling to in-notebook links, manual saving support in collaborative mode, and improved performance and memory usage when streaming text outputs.

Debugger and Console improvements

The debugger’s evaluate dialog has been replaced with an interactive console with syntax highlighting and code completion, and the variables panel now preserves its contents when switching editors. Selected breakpoints are now visually highlighted and breakpoints correctly handle empty lines and duplicate clicks. A visual indicator is displayed when the debugger is paused.

Debugger panels as well as console debugging panels now reference the cell execution count helping users relate breakpoints, call stacks and source code to the cells they originate from.

JupyterLab 4.5 includes many improvements to the debugger

For the Log Console, users can now configure the default log level via settings, as well as customise the toolbar.

New search functionality inside terminals

The terminal now includes search functionality, with search highlights that adapt to theme changes.

Search is now compatible with terminals

Media and content support

JupyterLab now includes built-in audio and video viewers, allowing users to open audio and video files directly from within JupyterLab.

Open audio and video files in JupyterLab

File browser enhancements

Uploaded files can auto-open, with controls for size limits and behavior, and a new allowFileUploads setting provides control over upload permissions.

There is now a menu option for creating new Python, R, or Julia files, and a “Select All” command has also been added, also accessible via the Ctrl + A keyboard shortcut.

Users can now configure file browser breadcrumbs through the settings editor options breadcrumbsLeftItems and breadcrumbsRightItems.

JupyterLab 4.5 includes many improvements to the file browser

Updates to file dialogs and navigation have addressed column spacing, preferred-directory handling and double-click behavior.

Keyboard shortcuts and commands

Code fold and unfold commands have been added and shortcuts for these can be set in the settings editor.

The “Show Workspace Indicator” command has been added to the command palette and the “Send Code to Console” shortcut has been restored. The previous issue involving editing shortcuts on Safari loosing focus, has been resolved.

With Jupyter Notebook 7.5.0, the O key has been defined as the keyboard shortcut to toggle cell outputs, restoring this familiar functionality from the classic notebook.

Settings

The settings editor now supports a toSkip configuration to hide specific plugins from view.

A new setting, addExtraLineOnCellMerge, allows to remove the extra line added when merging cells, which is expected behavior based on the classic notebook.

User interface and accessibility

JupyterLab can now automatically switch between light and dark themes when “Synchronize with System Settings” is enabled.

Dialog components display buttons and checkboxes on separate lines for better readability, and selections in the terminal under high-contrast themes have better visibility.

Keyboard navigation and tab order in the status bar has also been improved.

Update from JupyterCon

At JupyterCon 2025 in San Diego, the Jupyter Frontends team presented an update on features released since JupyterLab 4.0. This session covers the progress made since the previous conference in 2023. You can watch the full recording below.

Acknowledgements

Thank you to all the new contributors, the Jupyter Frontends team hopes to see you back!

JupyterLab: @Ankitaupadhaya, @CrafterKolyan, @EtiennePelletier, @Frank-Steiner, @Meriem-BenIsmail, @arjxn-py, @bnavigator, @bsundaram1, @dnlzrgz, @dotnetautor, @gjmooney
Notebook: @honnix, @jchen1223, @sangampaudel530

And thank you to returning contributors for their continued work!

JupyterLab: @Darshan808, @DenisaCG, @HaudinFlorence, @MUFFANUJ, @RRosio, @SylvainCorlay, @achhina, @afshin, @andrii-i, @bollwyvl, @brichet, @choldgraf, @cmarmo, @davidbrochart, @ianthomas23, @isabela-pf, @itsmevichu, @jasongrout, @jrdnbradford, @jtpio, @kathatherine, @kr-2003, @krassowski, @mahendrapaipuri, @martinRenou, @minrk, @nkn2022, @peytondmurray, @ritzdevp, @robertstrauss, @rschroll, @shreve, @skapin, @trungleduc, @yacchin1205, @yukiiii04, @zanieb
Notebook: @choldgraf, @itsmevichu, @jasongrout, @jtpio, @krassowski, @minrk

Thank you to all the people who tested and provided feedback for the pre-releases! Lastly, thank you to the weekly triage group for triaging JupyterLab, Notebook and JupyterLab Desktop issues: @RRosio, @krassowski, @andrii-i, @danyeaw among others who attend.

JupyterLab 4.4 and Notebook 7.4 are available!

2025-05-21T09:54:00+00:00

JupyterLab 4.4 has been released! This new minor release of JupyterLab includes 28 new features and enhancements, 76 bug fixes, 63 maintenance tasks and 34 documentation improvements. There were 56 contributors to this release.

Jupyter Notebook 7.4 has also been released, including many of the fixes and enhancements in this JupyterLab 4.4 release. While the releases on GitHub provide additional detail on the updates made to both JupyterLab 4.4 and Notebook 7.4, this article highlights some particularly notable changes.

Extension authors can refer to the Extension Migration Guide for information on API updates and details regarding changes to core packages.

Code console improvements

The code console prompt can now be positioned on the top, left, or right side of the console, in addition to the default bottom placement. The placement is persisted in the Prompt Cell Position setting. The console toolbar now includes buttons to:

Execute code
Restart the kernel
Clear the cells
Switch the kernel

Changing the position of the prompt cell in JupyterLab code consoles

Additional settings for console behavior have been added:

Clear Code Content on Execute (enabled by default) — When disabled, the code submitted for execution remains in the code editor, allowing for further edits.
Hide Code Input — When enabled, only the execution output is shown in the console.
Clear Cells on Execute — When enabled, only the last cell is displayed.

Toggling all the three new settings transforms the console into an interactive editor resembling an ephemeral notebook with a single cell.

The code console configured as a single executable cell

Settings import and export

Settings can now be exported to overrides.json from the Settings Editor, which can be used to pre-configure defaults in deployments or to restore settings.

Import and export settings from the Settings Editor

Workspace indicator

An opt-in workspace indicator is displayed on the top bar (next to the menu bar). It can be enabled in the Settings → View → Appearance → Show Workspace Indicator:

The workspace indicator

Support for collaboration without `RTC:` drive

Real time collaboration in previous versions of JupyterLab (which can be enabled by installing jupyter-collaboration package) was implemented by swapping the default JupyterLab file system drive to a collaborative drive with the RTC: prefix. This approach was incompatible with multiple extensions. JupyterLab 4.4 introduces the Content Providers API, which allows the next version of jupyter-collaboration to work without changing the drive prefix. This improves compatibility with extensions that do not support arbitrary drives.

Kernel subshells support

Kernel subshells, introduced in JEP 91, enable concurrent code execution in kernels that support them. When performing long-running computations (such as training a model), subshells enable users to:

Use ipywidgets with updates displayed immediately
Monitor kernel resource usage (e.g. memory usage)
Invoke arbitrary commands (e.g., refine code for a subsequent cell) while maintaining live access to previously defined variables

Subshells are supported by ipykernel 7 (currently in alpha).

To create a subshell, open context menu (right-click) over a notebook using a kernel supporting subshells and select “New Subshell Console for Notebook”. A new console panel will open allowing access to variables from the main session.

Creating a new subshell console for a notebook in JupyterLab 4.4

JupyterLab can automatically create subshells for comm messages if kernels support this feature. This enables concurrent execution of ipywidgets callbacks without requiring a user action. This behavior can be changed from the settings, with options to:

disable that feature to not use subshells for comms
(default) automatically create one subshell per comm-target (e.g. one subshell for all ipywidgets)
automatically create one subshell per comm (this can lead to issues if creating many comms)

The context menu, available under right mouse click in browsers, can now be disabled globally by toggling the Enable Context Menu option available in the Command Palette, or via the JSON Settings Editor in the Application Context Menu.

Slimmer status bar

The terminals counter no longer appears in the status bar if no terminals are open. The kernels counter can be disabled by toggling the Show the status bar item setting in Running Terminals and Kernels (code name showStatusBarItem).

Walkthrough video

If you prefer a more interactive tour of the new features mentioned in the post, check out the video below:

Acknowledgements

Thank you to all the contributors (list below is based on GitHub usernames):

JupyterLab: @Adam-D-Lewis @afshin @ajbozarth @AmberArr @andrewfulton9 @andreytaboola @andrii-i @bollwyvl @brichet @Carreau @claytonparnell @cmarmo @Darshan808 @davidbrochart @deephbz @dlqqq @echarles @fcollonval @fleming79 @holzman @hxrshxz @ianthomas23 @iisakkirotko @itsmevichu @JasonWeill @jesuino @joaopalmeiro @jtpio @kellyrowland @krassowski @kuraga @maitreya2954 @martenrichter @martinRenou @mgeier @MUFFANUJ @nkn2022 @Nriver @pawel99k @pdarshane @peytondmurray @pre-commit-ci @Princekumarofficial @Rishab87 @rpwagner @RRosio @rsaditya01 @SamuelMarks @SatyajitRedekar @SylvainCorlay @trungleduc @Zsailer
Notebook: @andrii-i @jdavid @jtpio @krassowski @RRosio

Special thank you to all the new contributors, the Jupyter Frontends team hopes to see you back!

Thank you to all the people who tested and provided feedback for the pre-releases! Lastly, thank you to the weekly triage group for triaging JupyterLab, Notebook and JupyterLab Desktop issues: @krassowski, @RRosio, @andrii-i, @danyeaw among others who attend.

Building AI Agents for JupyterLab using Notebook Intelligence

2025-02-24T18:03:00+00:00

Please note that this is not an official Jupyter subproject but an independent open-source tool for JupyterLab users who want to use GitHub Copilot as an AI coding assistant.

Notebook Intelligence (NBI) is an AI coding assistant and extensible AI framework for JupyterLab. (For an introduction to NBI see Introducing Notebook Intelligence and for basics of extending NBI see Building AI Extensions for JupyterLab blog posts.)

GitHub Copilot and other AI coding assistants are great at generating code and answering coding related questions. But they can do a lot more than generating text and code thanks to LLM features such as tool calling and AI agents. NBI provides an extensible AI framework to integrate tool calling and AI agents into JupyterLab Copilot Chat.

AI Agent extension example

What is tool calling and an AI Agent?

Tool calling is a feature of LLMs. It lets you introduce your own functions to LLM so that they can be called in response to chat prompts. LLM can convert natural language prompts to function calls with arguments. Tool calls are executed on the client side (i.e. Jupyter server) by your extension and only the function schema is provided to the LLM. Tool calling lets LLM interact with real time data, proprietary or external apps and services.

AI Agents are collections of tools that can run tasks on behalf of the user. Given a natural language prompt, LLMs can reason, create an execution plan and call multiple tools in a chain. NBI provides a framework to build these type of AI Agent integrations and handles the orchestration between LLMs and your tools.

AI Agent Extension Example

Let’s build an AI Agent for JupyterLab using Notebook Intelligence extension APIs. (The full source code for this extension is available here.) This will be an AI agent for map creation and notebook sharing. It will have the following capabilities:

Looking up geo-coordinates for an address
Showing maps centered at an address in the Copilot Chat UI
Creating notebooks that show maps centered at specified addresses
Sharing notebooks publicly using notebooksharing.space

The tasks above will be run by the AI Agent in response to natural language prompts by the user.

For this extension we will build four tools that will be integrated into JupyterLab Copilot Chat, for each of the tasks above. Tools are defined as classes derived from NBI Tool abstract class. A tool needs to implement the methods and properties defined in this base class.

Tool class provides the metadata information for the tool and implements the pre_invoke and handle_tool_call methods. pre_invoke method is called right before handle_tool_call with the tool arguments and it gives an opportunity for the tool to prompt for confirmation of the tool execution.

schema property of the Tool is the function schema based on OpenAI’s function calling schema. It lets you describe your function and its parameters as an object. A Tool is expected to return an object as response from the handle_tool_call method call.

Geo Coordinates Lookup Tool

This tool looks up geo-coordinates for an address using Nominatim library. pre_invoke method for this tool only shows a message in Chat UI before looking up for the geo-coordinates in handle_tool_call method.

class GeoCoordinateLookupTool(Tool):
    @property
    def name(self) -> str:
        return "geo_coordinate_lookup"

    @property
    def title(self) -> str:
        return "Get geo-coordinates from an address"
    
    @property
    def description(self) -> str:
        return "This is a tool that converts an address to a geo-coordinates"
    
    @property
    def schema(self) -> dict:
        return {
            "type": "function",
            "function": {
                "name": self.name,
                "description": self.description,
                "parameters": {
                    "type": "object",
                    "properties": {
                        "address": {
                            "type": "string",
                            "description": "Address to convert to geo-coordinates",
                        }
                    },
                    "required": ["address"],
                    "additionalProperties": False,
                },
            },
        }

    def pre_invoke(self, request: ChatRequest, tool_args: dict) -> Union[ToolPreInvokeResponse, None]:
        address = tool_args.get('address')
        return ToolPreInvokeResponse(
            message=f"Getting coordinates for '{address}'"
        )

    async def handle_tool_call(self, request: ChatRequest, response: ChatResponse, tool_context: dict, tool_args: dict) -> dict:
        address = tool_args.get('address')
        location = geolocator.geocode(address)
        return {"latitude": location.latitude, "longitude": location.longitude}

Get geo-coordinates tool

Map Response Generator Tool

This tool shows a map in Copilot Chat UI centered at geo-coordinates. In pre_invoke method this method only shows a notification message in Chat UI. In handle_tool_call method, this tool returns a HTMLFrame response that uses HTML to show a map centered at the requested location using Google Maps.

class MapResponseGeneratorTool(Tool):
    ...

    def pre_invoke(self, request: ChatRequest, tool_args: dict) -> Union[ToolPreInvokeResponse, None]:
        geo_coordinates = tool_args.get('geo_coordinates')
        latitude = geo_coordinates.get('latitude')
        longitude = geo_coordinates.get('longitude')
        return ToolPreInvokeResponse(
            message=f"Showing a map centered at latitude: {latitude} and longitude: {longitude}"
        )

    async def handle_tool_call(self, request: ChatRequest, response: ChatResponse, tool_context: dict, tool_args: dict) -> dict:
        geo_coordinates = tool_args.get('geo_coordinates')
        latitude = geo_coordinates.get('latitude')
        longitude = geo_coordinates.get('longitude')

        response.stream(HTMLFrameData(f"""<iframe width="100%" height="100%" frameborder="0" scrolling="no" marginheight="0" marginwidth="0" id="gmap_canvas" src="https://maps.google.com/maps?width=400&amp;height=400&amp;hl=en&amp;q={latitude},{longitude}&amp;t=&amp;z=11&amp;ie=UTF8&amp;iwloc=B&amp;output=embed"></iframe>""", height=400))
        response.finish()

        return {"result": "I showed the map"}

Below is an example prompt showing map centered at “Golden Gate Bridge, San Francisco”. Note that an address was provided to Copilot as the input but Map Response Generator Tool accepts only geo-coordinates as input. This is where LLM automatically decided that it needs to first call the Geo Coordinates Lookup Tool to get geo-coordinates for this address and then it called the Map Response Generator Tool with the geo-coordinates. LLM automatically chained multiple tools and NBI handled this chaining to get the correct response for the user’s prompt.

Map Response Generator Tool

Map Notebook Creator Tool

This tool creates a notebook centered at the specified geo-coordinates. In pre_invoke method this method only shows a notification message in Chat UI. In handle_tool_call method, the tool creates a notebook using nbformat library, saves it to disk and then opens the notebook in JupyterLab UI using the response.run_ui_command NBI method.

class MapNotebookCreatorTool(Tool):
    ...

    def pre_invoke(self, request: ChatRequest, tool_args: dict) -> Union[ToolPreInvokeResponse, None]:
        geo_coordinates = tool_args.get('geo_coordinates')
        latitude = geo_coordinates.get('latitude')
        longitude = geo_coordinates.get('longitude')
        return ToolPreInvokeResponse(
            message=f"Creating a map notebook for latitude: {latitude} and longitude: {longitude}"
        )

    async def handle_tool_call(self, request: ChatRequest, response: ChatResponse, tool_context: dict, tool_args: dict) -> dict:
        geo_coordinates = tool_args.get('geo_coordinates')
        latitude = geo_coordinates.get('latitude')
        longitude = geo_coordinates.get('longitude')

        now = dt.datetime.now()
        map_file_name = f"map_{now.strftime('%Y%m%d_%H%M%S')}.ipynb"

        nb = nbf.v4.new_notebook()
        header = """\
        ### This map notebook was created by an AI Agent using [Notebook Intelligence](https://github.com/notebook-intelligence)
        """

        install_code_cell = "%%capture\n%pip install folium"

        map_code_cell = f"""\
        import folium

        map = folium.Map(location=[{latitude}, {longitude}], zoom_start=13)
        map"""

        nb['cells'] = [
            nbf.v4.new_markdown_cell(header),
            nbf.v4.new_code_cell(install_code_cell),
            nbf.v4.new_code_cell(map_code_cell)
        ]
        nb.metadata["kernelspec"] = { "name": "python3"}
        nbf.write(nb, map_file_name)

        await response.run_ui_command("docmanager:open", {"path": map_file_name})

        return {"result": "I created and opened the map notebook"}

Map Notebook Creator Tool

This tool shares a notebook publicly by uploading it to notebooksharing.space and displays the link to the shared notebook.

In the pre_invoke method implementation, this tool asks for confirmation first as this operation is an undoable share of the notebook publicly. Only after the user confirms, handle_tool_call is executed. In handle_tool_call method the tool uploads the notebook at the notebook_file_path using nbss_upload library and then shows the link to the shared notebook on notebooksharing.space.

class NotebookShareTool(Tool):
    ...
    
    def pre_invoke(self, request: ChatRequest, tool_args: dict) -> Union[ToolPreInvokeResponse, None]:
        file_path = tool_args.get('notebook_file_path')
        file_name = path.basename(file_path)
        return ToolPreInvokeResponse(
            message=f"Sharing notebook '{file_name}'",
            confirmationTitle="Confirm sharing",
            confirmationMessage=f"Are you sure you want to share the notebook at '{file_path}'? This will upload the notebook to public internet and cannot be undone."
        )

    async def handle_tool_call(self, request: ChatRequest, response: ChatResponse, tool_context: dict, tool_args: dict) -> dict:
        file_path = tool_args.get('notebook_file_path')
        file_name = path.basename(file_path)
        share_url = nbss_upload.upload_notebook(file_path, False, False, 'https://notebooksharing.space')
        response.stream(AnchorData(share_url, f"Click here to view the shared notebook '{file_name}'"))

        return {"result": f"Notebook '{file_name}' has been shared at: {share_url}"}

Notebook Share Tool

Tool call schema definitions

It is important to define schemas of the tools clearly and disambiguate the tools as much as possible so that the LLM can invoke the proper tool based on the user prompt. LLM parses the user prompt, decides which tools to call and generates the input parameters for the call.

If current file or selection is made visible by the user, NBI can provide the file paths and content as context to the LLM. That way LLM can use those as additional context for a tool call. That is how Notebook Share Tool was able to access the current notebook file.

Tool chaining

After parsing the user prompt, LLM creates an execution plan and can call multiple tools in a chain. NBI handles this tool chaining for you. It is important to define your schemas with the chaining in mind. Consider defining matching tool outputs and inputs so that the output of a tool can be passed onto another one directly if needed.

Notice that in this extension example MapResponseGeneratorTool and MapNotebookCreatorTool both take in geo_coordinates (latitude, longitude) as input and GeoCoordinateLookupTool outputs geo_coordinates. This lets LLM to directly pass the output of GeoCoordinateLookupTool to MapResponseGeneratorTool and MapNotebookCreatorTool. It also lets a user to use an address to trigger MapResponseGeneratorTool and MapNotebookCreatorTool, because LLM knows that there is another tool it can call to generate input (geo_coordinates) from address for these tools.

Chat Participant

In NBI AI framework, AI Agents are defined as chat participants and tools are tied to specific chat participants. For our extension we create AIAgentChatParticipant as our participant (for more details on NBI extensions and chat participants see this blog). Our chat participant returns list of tools it defines from the tools property.

In handle_chat_request method our chat participant passes the request to the base ChatParticipant class to handle tool calling for us.

class AIAgentChatParticipant(ChatParticipant):
    @property
    def id(self) -> str:
        return "ai-agent"
    ...
    
    @property
    def tools(self) -> list[Tool]:
        return [GeoCoordinateLookupTool(), MapResponseGeneratorTool(), MapNotebookCreatorTool(), NotebookShareTool()]

    async def handle_chat_request(self, request: ChatRequest, response: ChatResponse, options: dict = {}) -> None:
        ...
        await self.handle_chat_request_with_tools(request, response, options)

NBI Extension

Finally we create our NBI extension class AIAgentExtension. This class basically registers our chat participant to NBI on extension activation.

class AIAgentExtension(NotebookIntelligenceExtension):
    ...

    def activate(self, host: Host) -> None:
        self.participant = AIAgentChatParticipant(host)
        host.register_chat_participant(self.participant)
        log.info("AI Agent example extension activated")

That is all there is to create an AI Agent for JupyterLab using Notebook Intelligence. The full source code for this example is available along with installation instructions for you to use as a reference and/or build on top.

I am looking forward to seeing the AI Agents built by the community. Please try the extension APIs and share your feedback using project’s GitHub issues! User feedback from the community will shape the project’s roadmap.

About the Author

Mehmet Bektas is a Senior Software Engineer at Netflix and a Jupyter Distinguished Contributor. He is the author of Notebook Intelligence, and contributes to JupyterLab, JupyterLab Desktop and several other projects in the Jupyter eco-system.

Introducing Notebook Intelligence!

2025-01-13T16:28:00+00:00

Please note that this is not an official Jupyter subproject but an independent open-source tool for JupyterLab users who want to use GitHub Copilot as an AI coding assistant.

I am thrilled to announce the release of Notebook Intelligence (NBI)! NBI is an AI coding assistant and extensible AI framework for JupyterLab. It uses GitHub Copilot under the hood and is inspired by its design principles. NBI greatly boosts the productivity of JupyterLab users with AI assistance powered by GitHub Copilot.

Generate code

Generate code, iterate on it

NBI integrates tightly with the notebook document. Using cell toolbar item “Generate code” or keyboard shortcut “Cmd + G” / “Ctrl + G”, you can launch the inline coding assistant popover to generate code cells.

Generate code popover

If the inline coding assistant is launched for a cell with existing code, then the generated code is shown in a diff view for approval.

Generate code with diff viewer

If you are not satisfied with the generated code, you can re-generate with an updated prompt. Diff viewer also lets you edit the generated code manually before accepting it.

Fix code in cell with NBI

Explain and fix code, troubleshoot errors reported

NBI adds a new sub menu to notebook cell context menu. Copilot can explain code in a cell or suggest fixes for any issues in it. Clicking these menu items opens Copilot Chat and generates a suggestion.

Copilot context menu

If the code cell has an output you can ask Copilot to explain it. If there are any errors reported, you can have Copilot to troubleshoot as well. These actions also take you to Copilot Chat interface.

Explain, fix, troubleshoot

Inline Completions

Notebook Intelligence integrates with JupyterLab’s inline completion APIs and provides code suggestions as you type in a code cell or a Python file.

Inline completions

Code suggestions are generated using GitHub Copilot. They are blazing fast and relevant to document you are working on. In addition to the code cell you are working on, the code in the surrounding cells are also used as context when generating suggestions.

Inline completions example

Copilot Chat

NBI provides a user friendly chat interface to chat with GitHub Copilot. You can ask questions related to coding.

Copilot Chat

If Copilot generates code snippets, they are rendered in a special format in a section with an action toolbar. Toolbar will have buttons to copy, insert, create new Python file and notebook from the snippet. Using these you can easily integrate the generated code into your project.

Copilot chat toolbar actions

Chat Commands

Chat interface also provides commands to generate new notebooks and Python code files based on your task described in the prompt. Commands start with “/” and a command auto-complete list is shown as you type. You can navigate between the commands using keyboard and choose a suggestion using “Enter” or “Tab” keys.

Chat command auto-complete

/newNotebook command

You can generate new notebooks from a prompt with the /newNotebook command. Notebook generation is shown interactively, a new empty notebook is created and opened, then code and markdown cells are added onto the notebook as they are generated by NBI and GitHub Copilot.

Generate notebook example

/newPythonFile command

You can also create new Python files from a prompt using the /newPythonFile command.

Generate Python file example

Getting Started with Notebook Intelligence

Notebook Intelligence is a JupyterLab extension published as a Python package. Simply install the package and restart JupyterLab. NBI will add a new sidebar item for Copilot Chat, a notebook context sub-menu, a cell toolbar item for “Generate code” and a status bar item for GitHub Copilot login status to JupyterLab UI. It will also be integrated with inline completion (AI suggestions for code completion).

pip install notebook-intelligence

Authentication with GitHub Copilot

Notebook Intelligence requires a GitHub Copilot subscription. NBI provides a user friendly interface to sign into your GitHub Copilot account from JupyterLab UI to activate access to your subscription.

GitHub Copilot authentication

Extensible Framework

Notebook Intelligence provides APIs to let developers extend its capabilities. You can add custom agents / chat participants, define tools (function calling) and add RAG capabilities to provide your own context to LLM for code / chat response generation. Stay tuned for my next blog post where I will walk you though extensibility features.

Notebook Intelligence is currently in beta and designed for Python (support for more languages coming soon). Please try it out and share your feedback and any feature requests using project’s GitHub issues! User feedback from the community will shape the project’s roadmap.

About the Author

Generative AI in Jupyter

2023-08-02T16:15:00+00:00

Jupyter AI brings generative artificial intelligence to Jupyter notebooks, giving users the power to explain and generate code, fix errors, summarize content, ask questions about their local files, and generate entire notebooks from a natural language prompt. Using its powerful magic commands and chat interface, Jupyter AI connects Jupyter with large language models (LLM) from providers such as AI21, Anthropic, AWS, Cohere, and OpenAI. We use LangChain to support all popular LLMs and providers, giving you access to new models as they are released. LangChain will let Jupyter AI use local models as well. Jupyter AI version 1.0, for JupyterLab 3, and Jupyter AI 2.0, for JupyterLab 4, are now available as free and open source software.

Jupyter AI is designed with responsible AI and data privacy in mind. You can pick which LLM and embedding model best suit your needs. The underlying prompts, chains, and other software are open source, so you can see exactly how your data is being used. Jupyter AI saves metadata about model-generated content in each AI-generated code cell, so you and your collaborators can track where AI-generated code enters your workflow. Finally, Jupyter AI only contacts an LLM when you ask it to, directly; it does not read your data or transmit it to models without your explicit consent.

Jupyter AI is an official subproject of Project Jupyter and is available now as free, open source software. We designed it based on the same principles that underlie all of Project Jupyter: we made it simple, easy to use, modular, and extensible, and we prioritized ethical considerations and social responsibility. We’d love to hear from you about how we can improve it!

Getting started with Jupyter AI

Start using Jupyter AI by installing the appropriate version with pip:

pip install 'jupyter-ai>=1.0,<2.0' # If you use JupyterLab 3
pip install jupyter-ai             # If you use JupyterLab 4

Then, launch JupyterLab. Jupyter AI provides two different interfaces to interact with LLMs. In JupyterLab, you can converse with a chat UI to assist you with your code. Also, in any supported notebook or IPython environment, including JupyterLab, Notebook, IPython, Colab, and Visual Studio Code, you can invoke LLMs using the %%ai magic command. Jupyter AI can turn any Jupyter Notebook session into a generative AI playground with support for text and image models.

Project Jupyter is vendor-neutral, so Jupyter AI supports LLMs from AI21, Anthropic, AWS, Cohere, HuggingFace Hub, and OpenAI. More model providers will be added in the future. Please review a provider’s privacy policy and pricing model before you use it. We’re also working on support for locally-deployed models, for maximum privacy. Once you have installed Jupyter AI, before you can use magic commands, you will need to authenticate to each model provider that you wish to use. For most providers, this involves setting an environment variable. The user documentation has detailed instructions for configuring model providers.

The chat interface has its own configuration panel for choosing a language model and an embedding model, and for authenticating to each model’s provider. A language model responds to users’ messages in the chat panel. When you ask the chat interface to learn about local files, it uses an embedding model to parse these files and to assist when you ask questions about them.

You can find full details about how to configure and use Jupyter AI in the user documentation.

The chat interface, your AI assistant

The chat interface puts you in conversation with Jupyternaut, a conversational agent using a language model of your choice.

Jupyternaut communicates primarily through text, and it can also interact with files in JupyterLab. It can answer questions as a general-purpose AI assistant, include selections from your notebooks with your questions, insert AI-generated output into your notebooks, learn from and ask questions about your local files, and generate notebooks from a prompt. Jupyternaut can only see the information you send it by sending chat commands; it only reads your data when you specifically ask it to.

To get started, you can ask Jupyternaut a question:

You can also highlight part of your notebook and include it with your prompt.

Using prompts that include the selected code, you can ask Jupyternaut to explain your code in plain English (or in any other language it can speak), make modifications to it, and identify errors in it. If you want, Jupyternaut can even replace your selection with its response. Please review AI-generated code before you run it, as you would review code written by another person.

For example, you can ask Jupyternaut to rewrite code by adding comments to it:

Jupyternaut sends the code to your chosen language model, then replaces the selection with the language model’s response.

Generating a notebook from a text prompt

Jupyter AI’s chat interface can generate an entire notebook from a text prompt. To do this, run the /generate command and provide a text description. Jupyternaut will use its AI language model to name the workbook and fill it with markdown and code cells. This may take a few minutes. While Jupyternaut is working, you can continue to use the chat UI, and Jupyternaut will continue generating your notebook.

Once Jupyternaut has finished generating your notebook, it will send you a message with its filename, so that you can open it. Please review any AI-driven code before you run it.

Learning from and asking about local files

You can use the /learn command to teach Jupyternaut about local files, so that you can use the /ask command to ask questions about them. For example, using the /learn command, you can teach Jupyternaut about Jupyter AI’s documentation:

When you learn local files, Jupyternaut uses an embedding model to convert data, then stores the output in a local vector database. Please review the privacy policy for each model, and be aware of any restrictions about sharing your local data with third-party model providers. Once the learning process is complete, you can ask a question with the /ask command. Using retrieval-augmented generation (RAG), Jupyternaut will append relevant info to your question from its vector database, then it will use the AI language model you selected to answer your question.

Notebooks as generative AI playgrounds with magic commands

Jupyter AI also provides magic commands that you can run in notebook cells and in the IPython command-line interface. To get started, run %load_ext jupyter_ai_magics, which will load the magics extension. You can then use Jupyter AI with the %%ai magic command. You can run %ai help to learn about all the options and commands you can run using the %ai line magic and %%ai cell magic commands.

Each %%ai command requires a model, typically specified as provider‑id:model‑id. To use a particular provider, you’ll need to set its API key using an appropriate environment variable or Python module. See the model providers section of the user documentation for specific information. Once you’ve provided the key to your model provider, you can run a magic command by specifying the model on the first line and specifying your prompt on subsequent lines.

You can use the -f or --format parameter to customize the format of the output, including HTML, math, source code, and images.

You can interpolate a variable name or expression in a prompt by enclosing it in braces (curly brackets).

Interpolation also works with the special In and Out variables, which contain the inputs and outputs of code cells. Note that a cell output can contain both text and markdown values.

Jupyter AI adds a special Err variable, which stores the errors that occur while executing code. By interpolating this variable into a prompt, you can use an AI language model to explain and correct an error in your code.

About the developers

Jupyter AI is an officially supported Jupyter subproject. The following Jupyter contributors built Jupyter AI.

Brian Granger is a Senior Principal Technologist at AWS. Brian is a cofounder of Project Jupyter, a member of the Jupyter Executive Council, and a board member of the PyTorch Foundation.

Andrii Ieroshenko is a Software Development Engineer at AWS. Andrii is a Project Jupyter contributor and JupyterLab Council member.

Piyush Jain is a Software Development Engineer at AWS working on open source contributions to Project Jupyter. He is also a member of the Jupyter Server team, actively participating in maintenance and development of the Jupyter Server project.

David Qiu is a Software Development Engineer at AWS working on Project Jupyter. Previously, David was researching physical chemistry at the University of Illinois at Urbana-Champaign.

Jason Weill is a Senior Front-End Engineer at AWS; a contributor to JupyterLab, Jupyter Governance, and Jupyter Scheduler; and a member of the JupyterLab Council, the Jupyter Security Working Group, and the Jupyter Diversity, Equity, and Inclusion Standing Committee.

How can you help?

We’re just getting started with generative AI in Jupyter. Please join us! We have a list of issues that could use your help, such as adding support for locally hosted LLMs.

Install and use the Jupyter AI extension. If you find any bugs or have suggestions, please create issues on GitHub.
Join the discussion about generative AI in Jupyter in the “Generative AI in Jupyter” topic on Discourse.
Contribute: Your bug reports, feature requests, and pull requests will help improve this project for everyone.

Note: An earlier version of this story said that users can choose which vector database to use with Jupyter AI. As of Jupyter AI 2.1.0, only FAISS is available; users cannot choose another vector database. Sorry for the error.

Jupyter Blog - AI

A User’s Journey with Plugin Playground: From First Idea to Installable JupyterLab Extension.

Motivation

Journey At a Glance

1.0: Pick Your Starting Path

2.0: Build Extension #1 Manually

2.1: Create the plugin file

2.2: Fill the missing pieces using the right sidebar

2.3: Load it and verify behavior

Expected result:

3.0: Build with AI

3.1: Give AI a precise request

What this block does:

3.2: Use AI + deterministic inserts together

4.0: Iterate Faster Before Handoff

5.0: Share for Review

6.0: Export as Wheel and Validate in Binder

6.1: Export .whl

6.2: Install in Binder

What this block does:

7.0: Export as Zip and Create a GitHub Repository

7.1: Export .zip

7.2: Bootstrap repository

What this block does:

What’s Next

Acknowledgements

About the Developers

Further reading

nb-cli: A Command-Line Interface for AI Agents and Notebook Automation

The Problem: Notebooks as Black Boxes

Key Features

Real World Use Cases

nb-cli in Action

Getting Started with nb-cli

About the developers

How can you help?

JupyterLab 4.5 and Notebook 7.5 are available!

Performance and windowing

Notebook improvements

Debugger and Console improvements

New search functionality inside terminals

Media and content support

File browser enhancements

Keyboard shortcuts and commands

Settings

User interface and accessibility

Update from JupyterCon

Acknowledgements

JupyterLab 4.4 and Notebook 7.4 are available!

Code console improvements

Settings import and export

Workspace indicator

Support for collaboration without RTC: drive

Kernel subshells support

Context menu opt-out

Slimmer status bar

Walkthrough video

Acknowledgements

Building AI Agents for JupyterLab using Notebook Intelligence

What is tool calling and an AI Agent?

AI Agent Extension Example

Geo Coordinates Lookup Tool

Map Response Generator Tool

Map Notebook Creator Tool

Notebook Share Tool

Tool call schema definitions

Tool chaining

Chat Participant

NBI Extension

Try it out and share your feedback!

About the Author

Introducing Notebook Intelligence!

Generate code, iterate on it

Explain and fix code, troubleshoot errors reported

Inline Completions

Copilot Chat

Chat Commands

/newNotebook command

/newPythonFile command

Getting Started with Notebook Intelligence

6.1: Export `.whl`

7.1: Export `.zip`

Support for collaboration without `RTC:` drive