thread-notebook: an AI copilot inside a Jupyter-style notebook
AI-powered Jupyter Notebook. Use AI to generate and edit code cells, automatically fix errors, and chat with your data
At a glance
- What is it?
- Thread is a Jupyter alternative that puts an AI copilot into the notebook editing experience. It installs from PyPI, runs locally, and can be pointed at Ollama or your own API key.
- Who is it for?
- Adopt thread-notebook if you want a Jupyter-style editor where the copilot sits in the same window and you are willing to run the model locally through Ollama or supply your own API key. Do not adopt it if you need a documented, versioned upgrade path or a stable public API surface: the README does not document rollback, and the repository ships a single PyPI release, v0.1.36, dated 2025-12-26.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 107 days ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What thread-notebook is for, and who it is for
Thread is a Jupyter alternative that integrates an AI copilot into the notebook editing experience. The README frames it as a Jupyter replacement rather than a plugin: you get the cell-based editing model you already know, with the assistant living inside the same interface. The stated features are natural language code edits, cell generation from natural language questions, a context aware chat sidebar, and automatic explanation or fixing of errors. The intended user is someone doing data science or analytics work in notebooks who wants the model to see the notebook context rather than copy-pasting code into a separate chat window. The README says Thread runs locally and can be used for free with Ollama or your own API key, which tells you the project assumes you either have a local model runtime or are willing to pay a provider directly.
How the AI features are wired into the notebook
The repository layout shows the split. There is a Next.js front end under src/, a proxy/ folder the README singles out for AI development, and a server_extension/ directory alongside shared-thread-notebook-utils/. The package.json dependencies confirm the shape of the stack: @jupyterlab/services and @jupyterlab/nbformat for talking to a Jupyter server and handling notebook format, @uiw/react-codemirror with @codemirror/lang-python for the editor, and the Vercel AI SDK packages ai, @ai-sdk/openai and @ai-sdk/anthropic for model calls. The chat and generation features therefore do not run inside the kernel. They run in the web application, which reads the notebook state and sends it to whichever model you configured. That is the reason the proxy folder exists as a separate service: it is the piece that sits between the browser and the model provider. The practical consequence is that your notebook content leaves the kernel process when you use a hosted model, and does not when you point Thread at a local Ollama instance.
Installing thread-notebook and running a first query
The README gives a single install command from PyPI. The distribution name is thread-notebook, and the importable or runnable name is the same.
pip install thread-notebookOnce installed, the README lists three equivalent ways to start the application. Any one of them should bring up the editor.
thread-notebookthreadjupyter thread-notebookTo use a local model, the README directs you to open the Settings icon in the bottom left of the interface, choose Model Settings, then navigate to Ollama and enter your model details. After that, the README says to use Ctrl or Cmd + K to run a query. That keyboard shortcut is the entry point for the natural language editing flow: you select or place the cursor in a cell, trigger it, and describe the change you want. If the shortcut does nothing, the model settings are the first thing to check, because the README treats the two as a sequence rather than independent features.
Running the repository in development mode
If you want to modify Thread rather than use it, the README describes a two-process setup: one terminal runs Jupyter Server, the other runs the Next.js front end. It starts with a yarn install at the repository root.
yarn installThen, in one terminal, the README says to run the development shell script, and in another to start the front end.
sh ./run_dev.shyarn devThe README states that navigating to localhost:3000/thread should show your local version of Thread running. Note the /thread path: the app is not served at the root. If you are working on the AI features specifically, the README points at the proxy folder, which needs its own install and then a dev server on port 5001.
yarn dev --port 5001That port is worth remembering, because a front end that cannot reach the proxy will look like a broken model configuration rather than a missing service.
Where thread-notebook is the wrong tool
The README does not document rollback, version pinning, or an upgrade procedure, and there is one PyPI release listed, v0.1.36, dated 2025-12-26. That combination matters if you are deploying this for a team. A notebook environment that silently changes under you is a different risk profile from a library you import, because the failure mode is a broken editing session rather than a stack trace. There is also no documented public API for the AI features, so anything you build on top of them is built against implementation details visible only in the source. The larger limitation is architectural: the copilot reads notebook state and sends it to a model. With a hosted provider, that means your data and your code leave the machine. The README offers Ollama as the fully offline path, and that is the only configuration the documentation describes as local. If your environment forbids outbound model calls and you cannot run Ollama, Thread's headline features are not usable in the way the README presents them. Finally, the homepage field is empty and the README's image links point at a thread.dev domain, so treat the repository as the source of truth rather than any site.
Thread compared with plain Jupyter and with an editor plugin
The realistic alternative is not another AI notebook but the combination most people already have: JupyterLab plus an assistant in a separate window, or a JupyterLab extension that adds a chat panel. The difference is where the context lives. With a separate chat window, you copy the cell, paste it, and paste the answer back, and the assistant never sees the rest of the notebook. Thread's design, as visible in its dependencies on @jupyterlab/services and @jupyterlab/nbformat, is to hold the notebook state in the same application that renders the chat, so the sidebar is described as context aware. That is a real difference in workflow, and it is also the reason the project carries more surface area than an extension: it is a full front end, a proxy service, and a server extension rather than a plugin loaded into someone else's shell. If you are happy with JupyterLab and only occasionally want help, the extension route keeps your existing environment and its upgrade path. If the back-and-forth is the part that bothers you, Thread is aimed squarely at that.
Editorial conclusion
Adopt thread-notebook if you want a Jupyter-style editor where the copilot sits in the same window and you are willing to run the model locally through Ollama or supply your own API key. Do not adopt it if you need a documented, versioned upgrade path or a stable public API surface: the README does not document rollback, and the repository ships a single PyPI release, v0.1.36, dated 2025-12-26. Before committing, verify that the Settings panel accepts your model details, that Ctrl or Cmd + K triggers a query in your browser, and that the AGPL-3.0 terms fit how you intend to distribute anything built on it.
Frequently asked questions
What is the main purpose of thread-notebook?
It is a Jupyter alternative that integrates an AI copilot into the notebook editing experience, so you can generate and edit cells in natural language, ask questions in a chat sidebar, and have errors explained or fixed. The README says it runs locally and can be used for free with Ollama or your own API key.
How do I install thread-notebook?
The README gives a single command, pip install thread-notebook, and then lists thread-notebook, thread, or jupyter thread-notebook as ways to start it.
Can thread-notebook run without sending my code to a hosted model?
The README describes using Ollama for a fully offline AI experience, configured through the Settings icon, then Model Settings, then the Ollama section where you enter your model details. It also supports supplying your own API key, which would send requests to that provider instead.
Which keyboard shortcut starts an AI query in thread-notebook?
The README says to use Ctrl or Cmd + K and try running a query to see how it looks. It presents this after the Ollama setup steps, not before.
What licence does thread-notebook use?
The repository lists AGPL-3.0. The README does not discuss what that means for applications built on top of Thread, so the licence text itself is the thing to read.
Community notes