# jupyterlab-lsp: LSP-powered diagnostics, hover and rename for JupyterLab notebooks

> jupyterlab-lsp connects JupyterLab to language servers for hover documentation, inline diagnostics, jump-to-definition, autocompletion and rename. It requires JupyterLab 4.1.0 through 4.x and a separately installed language server for each language you want to cover.

**jupyter-lsp/jupyterlab-lsp** — Coding assistance for JupyterLab (code navigation + hover suggestions + linters + autocompletion + rename) using Language Server Protocol

- Repository: https://github.com/jupyter-lsp/jupyterlab-lsp
- Website: https://jupyterlab-lsp.readthedocs.io
- Stars: 2,002 · Forks: 157
- Language: TypeScript
- License: BSD-3-Clause
- Published: 2026-10-11 · Updated: 2026-10-11 · Language: en
- Canonical page: https://hysenlabs.com/projects/jupyter-lsp-jupyterlab-lsp

## What jupyterlab-lsp adds to notebooks: eight features via Language Server Protocol

jupyterlab-lsp is a JupyterLab extension that connects the notebook editor to language servers, enabling IDE-style features in the browser. An underline on hovered code signals that the language server has information about it; pressing Ctrl reveals a tooltip showing the signature, module documentation or any other data the server provides.

Diagnostics appear inline: the severity is color-coded in red for critical errors and orange for warnings. Hovering over underlined code shows the detailed message. Jump to Definition and Jump to References are available from the context menu or via Alt+click; pressing Alt+O jumps back. Placing the cursor on a variable highlights all usages.

Rename works for variables, functions and more across both notebooks and the file editor. The keyboard shortcut F2 opens the rename dialog from the cursor position; the context menu provides the same action for pointer-driven workflows. The diagnostics panel, opened from the JupyterLab command palette or the context menu, lets you sort and jump between all current diagnostics and filter or copy individual messages. The README notes that examples show Python, but most features also work in R, bash, TypeScript and other supported languages.

## Two extensions in one package: the Python server extension and the lab frontend

A single jupyterlab-lsp install provides two components. The Python server extension runs inside the Jupyter server process and mediates between the browser frontend and any running language servers. The lab extension runs in the browser and handles the UI: the hover tooltips, the underlines, the completion menu and the diagnostics panel. Both are installed together by the same pip or conda command.

Language servers themselves are separate installs. The extension does not bundle them; you choose and install each one based on the languages you work with. This separation means updating a language server (for example, picking up a newer version of python-lsp-server) does not require reinstalling jupyterlab-lsp. Two conda-forge bundles collapse the steps for common cases: jupyter-lsp-python and jupyter-lsp-r each install the server extension and the matching language server together. For all other languages, installation is manual.

## Installing jupyterlab-lsp and language servers: pip, conda, or the conda bundles

The README recommends using a virtualenv or conda env. Installing JupyterLab and the extension together with pip:

```bash
pip install 'jupyterlab>=4.1.0,<5.0.0a0' jupyterlab-lsp
```

Or with conda:

```bash
conda install -c conda-forge 'jupyterlab>=4.1.0,<5.0.0a0' jupyterlab-lsp
```

After that, install language servers for the languages you use. For Python via pylsp and R via languageserver:

```bash
pip install 'python-lsp-server[all]'
R -e 'install.packages("languageserver")'
```

Or via conda:

```bash
conda install -c conda-forge python-lsp-server r-languageserver
```

For JavaScript, HTML, Markdown or other NodeJS-based servers, an appropriate NodeJS version must also be installed. After installing the extension, a JupyterLab restart is required. The README notes that visiting each server's own repository is worthwhile, as many provide configuration options that go beyond the defaults.

## Kernel and LSP completions are merged, with a 0.6s fallback threshold

When a kernel is running, jupyterlab-lsp merges kernel-provided suggestions with LSP suggestions in the completion menu. Kernel completions include things like dictionary keys and DataFrame column names that static analysis cannot see. LSP completions come from the language server's understanding of the code.

If the kernel is too slow to respond, the extension falls back to LSP suggestions alone. The default threshold is 0.6 seconds. There is also a separate setting to skip kernel completions entirely when the kernel is busy, which avoids waiting for the 0.6s timeout in that case.

Both sources can be controlled through the disableCompletionsFrom list in the completion section of Advanced Settings. Adding 'Kernel' disables kernel completions. Adding 'LSP' disables LSP completions, leaving kernel completions only. Adding both disables all completions from either source. This design means the setting name is somewhat counterintuitive when used to switch away from LSP in favor of kernel completions: you add a source to a 'disable' list to keep the other.

## continuousHinting is off by default and requires explicit enabling

Completion triggers automatically on certain characters. In Python, a dot triggers the completion list. This on-keystroke trigger is distinct from continuous hinting, which shows suggestions as you type even without a trigger character.

Continuous hinting is disabled by default. The README describes it under 'Automatic Completion and Continuous Hinting' and notes that you can choose to receive suggestions as you type by enabling the continuousHinting setting in Advanced Settings. Users who expect suggestions to appear automatically on every keystroke will need to enable this explicitly.

Automatic signature suggestions are separate from the completion list. Function signatures appear automatically when you start typing a function call, without any trigger character or keyboard shortcut. Kernel-less autocompletion, the advanced static-analysis path that works without a running kernel, is available through the language server for static types and definitions that a kernel could not provide.

## JupyterLab 4.1.0 to 4.x only: what the version constraint means in practice

jupyterlab-lsp requires JupyterLab version 4.1.0 or later and strictly below 5.0.0a0. Python 3.9 or later is required on the server side. For NodeJS-based language servers, an appropriate NodeJS version is also needed; the README does not specify which version.

JupyterLab 2.x is explicitly called out as requiring a different installation procedure; the README links to version 2.x documentation rather than covering it inline. JupyterLab 3.x is not mentioned in the README's prerequisites section at all, which means the documented path only covers 4.1.x.

The implication for existing installations is worth checking before upgrading: if you upgrade JupyterLab from 3.x to 4.1.x to use jupyterlab-lsp, the conda or pip version constraints must be satisfied by the installed JupyterLab version, or the install will fail.

The project is BSD-3-Clause licensed; v5.3.0 was released 2026-04-02, with the most recent repository push on 2026-06-21.

## Language server coverage: the package.json dev servers and the Microsoft list

jupyterlab-lsp does not dictate which language servers you install. The README says that in general, any LSP server from the Microsoft language server list should work after some additional configuration. The project maintains its own list of supported language servers with installation hints for common package managers.

The dev dependencies in package.json reveal which servers the project tests against: bash-language-server at ^4.9.2, dockerfile-language-server-nodejs at ^0.7.1, pyright at ^1.1, sql-language-server at ^1.2.1, typescript-language-server at ^4.3.3, yaml-language-server at ^1.0.0, and several vscode-hosted servers for CSS, HTML and JSON. These are development-time dependencies used in the test suite, not runtime requirements for users.

For Python specifically, the recommended server is pylsp (python-lsp-server), installable with the [all] extra to get all optional capabilities. For R, the languageserver package from CRAN is the documented option. Both are available on conda-forge. Other languages require finding and installing an appropriate server from the supported list.

## Conclusion

jupyterlab-lsp is worth installing if you write Python, R or other LSP-covered languages in JupyterLab 4.1.x and want inline diagnostics, hover documentation and rename without switching editors. Verify your JupyterLab version is 4.1.0 or later before installing; the 4.1.x upper bound excludes JupyterLab 5, and the 2.x path uses a different procedure. Anyone content with kernel completions alone can skip the extension, or disable only the LSP completion source by adding 'LSP' to the disableCompletionsFrom setting rather than uninstalling.

## FAQ

### How do I install jupyterlab-lsp?

Install JupyterLab and the extension together with pip install 'jupyterlab>=4.1.0,<5.0.0a0' jupyterlab-lsp, or use the conda-forge channel. Then install a language server for each language you use. Python and R can be installed together using the conda-forge bundles jupyter-lsp-python or jupyter-lsp-r.

### Does jupyterlab-lsp work with JupyterLab 5?

Current releases require JupyterLab 4.1.0 or later but below 5.0.0a0. JupyterLab 5 is outside the supported range. JupyterLab 2.x requires a different procedure documented in the version 2.x docs.

### What language servers work with jupyterlab-lsp?

The README says any LSP server from the Microsoft language server list should work after some configuration. Python users can install python-lsp-server, R users can install the languageserver CRAN package. Installation hints for common managers are on the project's supported language servers list.

### How do I enable continuous hinting in jupyterlab-lsp?

Enable the continuousHinting setting in JupyterLab's Advanced Settings. It is off by default; with it enabled, completion suggestions appear as you type without needing a trigger character like a dot.

### Can jupyterlab-lsp work without a running kernel?

Yes. jupyterlab-lsp provides kernel-less autocompletion through the language server's static analysis, which works without a running kernel. When a kernel is available, kernel suggestions are merged with LSP suggestions; if the kernel does not respond within 0.6 seconds, only LSP suggestions are shown.

## Sources

- [jupyter-lsp/jupyterlab-lsp on GitHub](https://github.com/jupyter-lsp/jupyterlab-lsp)
- [License: BSD-3-Clause](https://github.com/jupyter-lsp/jupyterlab-lsp/blob/main/LICENSE)
- [Project website](https://jupyterlab-lsp.readthedocs.io)
- [README](https://github.com/jupyter-lsp/jupyterlab-lsp/blob/main/README.md)
- [Releases](https://github.com/jupyter-lsp/jupyterlab-lsp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jupyter-lsp-jupyterlab-lsp