Jupyter Blog - Jason Weill

November 2024 Jupyter Community Call

2024-10-21T20:12:00+00:00

Hey, Jupyter community! We want to see the cool things you’re doing with Jupyter, so the Diversity, Equity, and Inclusion (DEI) standing committee is holding an open call with the community for people to share and chat about their work. Think of it as a “virtual JupyterCon”: It’s a place to announce and share fun things happening in the Jupyter community.

We encourage brief (5 minutes or less) presentations with a demo or screen share, as needed. If you have a GitHub repo or demo web site, please share it!

Event details

November 13, 2024, at 9:00 AM PST (17:00 UTC; your timezone)
Agenda (add yourself) on HackMD
Meet on Zoom

Anyone can attend, for free! Anyone can present; add yourself to the agenda above. Anyone can sit in on the call. Presenters will lead a demo and spend a few minutes answering questions. Topics will be targeted at a broad Jupyter audience, not just programmers.

Watch previous calls in our YouTube playlist.

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.

JupyterLab 4.0 is Here

2023-06-05T20:04:00+00:00

The Jupyter contributor community is proud to announce JupyterLab 4.0, the next major release of our full-featured development environment. The package is now available on PyPI and conda-forge. You can upgrade by running pip install --upgrade jupyterlab or conda install -c conda-forge jupyterlab. We have updated our JupyterLab Documentation for this new version.

Here are some of the major new features in JupyterLab 4.0, excerpted from our changelog:

JupyterLab is now faster, thanks to improvements such as CSS rules optimization, CodeMirror 6, MathJax 3, and notebook windowing. By rendering only the parts of a notebook that fit in the web browser viewport, JupyterLab 4 is much more efficient than JupyterLab 3 was when working with large notebooks.

There are additional performance improvements available via opt-in settings. You can help test them out by enabling them in your settings:

Faster tab-switching on Chromium browsers:
“Settings” → “JupyterLab Shell” → switch “Hidden mode” to “contentVisibility”
Better performance with long notebooks:
“Settings” → “Notebook” → switch “Windowing mode” to “full”

An upgraded text editor. CodeMirror, the text editor used for cells and file editors, has been updated to CodeMirror 6. This brings important accessibility and performance improvements as well as better customization capabilities. We have also improved the editor settings to be more powerful and more flexible.

We have moved real-time collaboration (RTC) into a separate package, jupyter_collaboration, version 1.0.0 of which is now available. Highlights include support for displaying multiple cursors and selections, and support for registration of new shared model types. If you’d like to use RTC in JupyterLab 4, please install the jupyter_collaboration package.

A new extension manager. In JupyterLab 4, the Extension Manager includes both prebuilt Python extensions and extensions from pypi.org. Installing from PyPI removes the need to build when installing an extension using the Extension Manager. Developers can provide an alternative package repository to display their own set of extensions.

Improved document search. The Search and Replace functionality has been improved with new features when searching in a notebook, including highlighting matches in rendered markdown cells, searching in the current selection, multi-line search, replacement using regular expression capture-group references, and replacement while preserving case.

UI improvements, including a reworked running kernels section, an “Add a new cell” button at the bottom of a notebook, a dialog to display keyboard shortcuts as in the Classic Notebook (use Ctrl + Shift + H), and displaying the first line of collapsed cell inputs and outputs.

Accessibility improvements, including improved focus and keyboard navigation in the file browser, more ARIA roles and labels for UI elements, and the main menu collapsing to a hamburger menu if there is not enough space to display all items.

Development tool updates to TypeScript v5, Yarn v3, React v18, and Lumino v2. We recommend using Node.js v18 or newer, to ensure that you’re using a version that will continue to receive updates through at least the end of 2023.

Bug fixes. More than 100 bugs have been addressed and resolved, enhancing JupyterLab’s stability and performance. You can find a full list of bug fixes on GitHub.

In addition, a few features in JupyterLab 4 have also been backported to JupyterLab 3.6, but if you’re upgrading from 3.5 or earlier, they will also be new to you:

The dual-mode settings editor now offers a JSON editor and a new, user-friendly interactive mode, built with React JSON Schema. This intuitive interface makes customization accessible to users of all skill levels.

The cell toolbar, a graphical interface for quick cell manipulation (copy, move, insert, delete), provides an alternative to hotkeys or dropdown menu editing. The cell toolbar appears in the current cell as long as there is room for it.

Notifications come from extensions and from JupyterLab itself, for real-time announcements, alerts, and updates. This enhances JupyterLab’s responsiveness and provides a way to stay informed about ongoing processes. Announcements from the JupyterLab team, including new version notifications, can be disabled; see the documentation for instructions.

Thank you to all the users, contributors, extension developers, and community members who helped make this major new release possible. We encourage everyone to try this new version out. If you notice anything unexpected, please file an issue on GitHub or ask us about it on Discourse.

Author’s note: This article is published on behalf of Project Jupyter. I appreciate the contributions of the JupyterLab developers who contributed to it.

Announcing a New Jupyter Governance Model and Our First Executive Council

2023-01-13T21:08:00+00:00

After a lengthy planning and preparation process, Project Jupyter is proud to announce its new governance model, including an Executive Council (EC), Software Steering Council (SSC), Distinguished Contributors, Standing Committees, Working Groups, and Subprojects. We have also elected our first Executive Council, a group of contributors who are now leading Jupyter in 2023.

This governance transition was motivated by lessons we’ve learned as the project grew dramatically in the last decade. Our previous model, used since the project’s early days as IPython and influenced by the BDFL (Benevolent Dictator for Life) model of Python itself, had proven insufficient to meet our current needs. Our former Steering Council consisted of members who had made significant contributions to Jupyter and IPython. We decided that it would be better for the project if we separated the roles of “major contributor” and “decision maker.”

First, we developed the Jupyter Distinguished Contributors program to recognize the contributions of our community members. Distinguished Contributors do not have active responsibilities or decision-making authority. Next, we designed a model that would allow a project as broad as Jupyter, both in terms of technical architecture and use cases, to grow in a healthy way. We aimed to create structures to help us make technical decisions effectively, to grow the human and social aspects of the project and community in a sustainable manner, and to manage the diverse, multi-stakeholder nature of Jupyter with fairness to all. Jupyter’s stakeholders range from individual volunteers to some of the largest tech firms in the world, from academics to government and industrial users. Our intention is that with our new governance model, all of our stakeholders can create ideas, tools, spaces and communities around interactive computing.

Jupyter’s new governance model

The project website provides an overview of the new governance model as well as details on its individual components. Please refer to those pages for specific information. In summary, the BDFL+Steering Council structure has been replaced by a small, elected Executive Council (EC) that works together with a Software Steering Council (SSC) made up of representatives from our subprojects, working groups, and standing committees. Every year, we will continue to recognize new Distinguished Contributors. This new governance model has replaced the previous model as of January 2023.

The BDFL, Steering Council, and institutional partners have served us well in the past, and Jupyter is grateful for all of their support. We are optimistic about the work to be done by our new Executive Council, by our Software Steering Council, by our large community of contributors, and by all of our users who constantly provide thoughtful and informed feedback.

Executive Council (EC)

Our first executive council includes Afshin Darian, Brian Granger, Jason Grout, Fernando Pérez, Ana Ruvalcaba, and Steven Silvester.

The EC is ultimately responsible for many aspects of Jupyter’s governance, including legal, financial, and operations matters. The members of the EC actively work to carry out Jupyter’s mission in accordance with its values. The EC delegates some work to the Software Steering Council, Software Subprojects, Standing Committees, and Working Groups. These other bodies report to the EC, and the EC is expected to support, oversee, manage, and ensure the success of operations across Jupyter. For more detail, see the Executive Council document.

The first EC includes the following individuals, serving either full 2-year terms or partial 1-year terms:

Afshin Darian, QuantStack, 2 year term
Brian Granger, AWS and Cal Poly San Luis Obispo, 2 year term
Fernando Pérez, UC Berkeley, 2 year term
Jason Grout, Databricks, 1 year term
Ana Ruvalcaba, Cal Poly San Luis Obispo, 1 year term
Steven Silvester, MongoDB, 1 year term

Our first three EC members, who will serve a two-year term, are Darian, Brian, and Fernando. These three people elected one new member for the EC; voters elected two others from a slate of nine candidates. These newly elected members are Jason Grout, Ana Ruvalcaba, and Steven Silvester. All three of these new members will serve a shortened one-year term on the council. In the future, we will have elections every year, selecting new members for two-year terms. Members can serve up to two consecutive full terms.

We held an election in November and December 2022 in which all members of the Union of Councils (UoC) could participate, both as candidates and as voters. The UoC includes all members of all Standing Committees, Working Groups, and Subproject Councils. A person who nominated a candidate (either themself or someone else) wrote a statement of their interest, qualifications, and experience. In total, we received nine nominations for this election. We collected the candidates’ statements into a voter’s guide, and also included instructions about how to vote. We used ranked-choice voting with a single transferable vote, as implemented by Apache STeVe. We collected votes from UoC members via Google Forms. Each voter could select one or more candidates, in descending order of preference, without ties. A tabulator then ran the results through a data prep script, then into Apache STeVe’s tabulation script, to determine the winners through a series of rounds. (In our first election, because I was neither an EC member nor a candidate, I volunteered as tabulator.)

In each round, the tabulation script looked for two candidates with more than a quota, a winning threshold, of votes. If it found two, then it was done. If not, then any winner with more votes than the quota had its surplus votes reallocated to lower-priority candidates, and a candidate with too few votes was eliminated, then in the next round, the script repeated the process from the beginning. In total, it took 8 rounds to select 2 winners from our slate of 9 candidates.

Software Steering Council (SSC)

The SSC has jurisdiction over software-related decisions across Project Jupyter, with a primary focus on coordination across projects and decisions that have impact across many Jupyter Subprojects. It is also a mechanism for representatives of each project to share information and expertise. Technical decisions and processes where the SSC isn’t explicitly involved are automatically delegated to the individual projects to manage their day-to-day activities, create new repositories in their orgs, etc., with independence and autonomy. For more detail, see the Software Steering Council document.

The first SSC includes the following individuals who each represent one subproject or working group:

Jupyter Accessibility: Isabela Presedo-Floyd
Jupyter Foundations: Paul Ivanov
Jupyter Kernels: Johan Mabille, QuantStack
Jupyter Notebook: Eric Charles, Datalayer / Anaconda
Jupyter Security: Rick Wagner
Jupyter Server: Zach Sailer, Apple
Jupyter Standards: Carol Willing, Noteable
Jupyter Widgets: Itay Dafna, Netflix
JupyterHub and Binder: Min Ragan-Kelley, Simula Research Lab
JupyterLab: Frédéric Collonval, QuantStack
Voilà: Sylvain Corlay, QuantStack

Each of the above individuals was elected by the Council of their respective subproject or working group.

How to get involved

The Jupyter EC holds office hours every Tuesday at 10:00 AM, U.S. Pacific time. You can find information about joining these office hours on the Jupyter Community Calendar. You can also contact the EC at jupyter-executive-council@googlegroups.com.

Jason Weill is a Senior Front-End Engineer at Amazon Web Services; 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. This article does not represent the official position of amazon.com or any of its subsidiaries.

Introducing Jupyter Scheduler

2022-12-14T15:26:00+00:00

The Open Source Jupyter team at AWS is proud to announce the release of Jupyter Scheduler, a JupyterLab extension that can run your Jupyter notebooks in the background. Jupyter Scheduler was developed from the start as an open-source project under the umbrella of the Jupyter project and governance. You can set up your notebooks to run once or on a schedule. By default, Jupyter Scheduler runs notebooks on your local system where Jupyter Server is installed; you can also extend the scheduler to run your notebooks in the cloud, on an on-premise cluster, on JupyterHub, or even on supercomputers.

We hope you’ll find Jupyter Scheduler useful for running notebooks periodically, such as daily or weekly reports. You can install it in JupyterLab by running pip install jupyter_scheduler, then restarting JupyterLab. You can create jobs (single runs of an individual notebook) and job definitions (scheduled recurring notebook jobs) in two ways. You can right-click on a notebook in the file browser and choose “Create Notebook Job” from the context menu, or you can use the new toolbar button in an open notebook file.

When you right-click on a notebook file in the file browser, a “Create Notebook Job” option appears in the context menu.

In a notebook, the “Create Notebook Job” option appears on the right of the toolbar.

You can give your notebook job or job definition a name, choose an environment to run it in, select different output formats, and provide parameters that are set as local variables when your notebook gets executed. This parameterized execution is similar to Papermill; Jupyter Scheduler provides a UI for managing and accessing the outputs of your notebook jobs inside JupyterLab.

You can use the Create Job form to run a notebook once or to create a job definition that runs on a schedule.

In addition, if you select “Run on a schedule,” you can run your job on a recurring schedule. The scheduler provides a few useful shortcuts to, for example, run your notebook at a specified interval by the minute, hour, day or week. You can also specify a custom schedule in crontab format.

You can schedule a job definition using preset intervals, such as every weekday.

You can also select “custom schedule” and specify a cron expression for the notebook job definition’s schedule.

Once you’ve created a job or job schedule, you can use the “Notebook Jobs” icon on the launcher to view lists of jobs and job definitions. Each item’s name links to a detail view.

With the Jupyter Scheduler extension installed, JupyterLab’s launcher screen shows a “Notebook Jobs” button in the “Other” section. Click on it to view a list of jobs or job definitions.

The list view shows a list of notebook jobs and a list of notebook job definitions. Each one includes links to view details, to download files, and buttons to take quick actions on them.

The Job Detail view shows all available details for one job or one job definition.

When one of your jobs has completed, you can download its files from the list or detail view. When your notebook runs, the scheduler saves a copy of the input file, so that even if you later change the file, it captures the state of the notebook at the time your job ran. Jupyter Scheduler uses unique names for the input and output files so that rerunning the same notebook produces new files every time.

Jupyter Scheduler uses a REST API to create, update, delete and manage jobs and job definitions. You can also customize Jupyter Scheduler by plugging in your own scheduler class, for example, to replace the existing SQLite database or to run jobs in the cloud. AWS SageMaker Studio actually uses Jupyter Scheduler, with custom classes, as part of its automated notebooks feature, announced earlier this year. See the Jupyter Scheduler operator documentation for more information about how to write and use your own scheduler.

We’d love to hear what you think about Jupyter Scheduler! You can check out Jupyter Scheduler’s documentation on ReadTheDocs. Please open issues with ideas for enhancements and about any bugs you find. If you’d like to contribute code, see the Jupyter Scheduler contributors guide.

This article does not represent the official position of amazon.com or any of its subsidiaries.

About the authors

Andrii Ieroshenko is a Software Development Engineer at AWS. Previously, Andrii worked on the Notifications project as a part of the Jupyter Cal Poly student internship program.

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.