jupyter-live-kernel

Execute stateful Python code through a live Jupyter kernel with persistent variables.

5|2|Updated May 26, 2026
One-click install
npx skills add https://github.com/perasyudha/Nyxora --skill jupyter-live-kernel-perasyudha
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/perasyudha/Nyxora/tree/main/packages/core/playbooks/data-science/jupyter-live-kernel
Command: npx skills add https://github.com/perasyudha/Nyxora --skill jupyter-live-kernel-perasyudha

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires jupyterlab, uv, and includes scripts (resource) components.

What problem does it solve? One-shot code execution loses all state between runs, forcing you to re-import libraries, reload data, and rebuild variables on every step. This Skill provides a persistent Python REPL backed by a live Jupyter kernel so you can explore data, inspect DataFrames, and iterate on code incrementally. ## Core Features & Use Cases - Stateful Code Execution: Run Python code against a live kernel where variables, imports, and objects persist across executions. - Variable Inspection: List and preview live kernel variables to debug and understand intermediate results. - Notebook Cell Editing: Insert, replace, and delete cells in a notebook, plus restart-and-run-all verification for clean top-to-bottom runs. - Use Case: While exploring a new dataset, load it into a pandas DataFrame once, then iteratively filter, plot, and transform it across multiple executions without reloading. ## Quick Start Start a JupyterLab server and use the jupyter-live-kernel skill to run Python code in a scratch notebook so my variables persist between executions.

Frequently Asked Questions about jupyter-live-kernel

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run Python code with persistent state between executions?

Use a live Jupyter kernel as a stateful REPL. Start a JupyterLab server, create a kernel session via the Jupyter REST API, then execute code against the same notebook so variables, imports, and objects persist across calls.

When should I use a Jupyter kernel instead of one-shot code execution?

Use a live kernel for iterative exploration, data science, and tasks where you build state incrementally. Use one-shot execution for standalone scripts that need no persisted variables, and a terminal for shell commands, installs, and git operations.

How do I inspect variables in a running Jupyter kernel?

Run the variables subcommand with the notebook path to list all live variables, or pass a variable name to preview its value. This works because the kernel retains its full namespace between executions.

Why does the first Jupyter kernel execution time out?

The kernel needs time to initialize after the server starts, so the first execution may exceed the default 30-second timeout. Retry the execution or pass a longer timeout such as 60 or 120 seconds for setup and heavy computation.

Can I install packages for the live Jupyter kernel?

The kernel uses JupyterLab's Python environment, so packages must be installed into that environment before use. Install them into the JupyterLab tool environment first, then import them in your executed code.