jupyter-live-kernel

Executes Python code in a stateful live Jupyter kernel with persistent variables.

1|Updated Jun 1, 2026
One-click install
npx skills add https://github.com/Araara7/hermes-skills --skill jupyter-live-kernel-araara7
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/Araara7/hermes-skills/tree/main/data-science/jupyter-live-kernel
Command: npx skills add https://github.com/Araara7/hermes-skills --skill jupyter-live-kernel-araara7

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 redefine variables on every step. This Skill provides a persistent Python REPL backed by a live Jupyter kernel so you can explore data 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 inspect DataFrames and intermediate results without re-running code. - Notebook Cell Editing: View, insert, replace, and delete notebook cells, plus restart-and-run-all verification for clean top-to-bottom runs. - Use Case: Load a CSV into a pandas DataFrame, inspect its columns, try several cleaning transformations step by step, and only keep the cells that work—exactly like working in a Jupyter notebook. ## Quick Start Start a JupyterLab server, create a scratch notebook session, then ask the agent to execute Python code in the live kernel and inspect the resulting variables.

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 send execute commands. Variables, imports, and objects survive across every execution call.

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

Use a live kernel for iterative exploration, data science, and ML work where state must persist across steps. Use one-shot execution for standalone scripts that need no carried-over variables, and a terminal for shell commands and installs.

What are the prerequisites for running a live Jupyter kernel?▼

You need uv installed, JupyterLab installed via uv tool install, and a running Jupyter server. A kernel session must also be created through the Jupyter REST API before any code can execute.

Why does the first code execution against a Jupyter kernel time out?▼

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

Can I install packages for the live Jupyter kernel?▼

Yes, but packages must be installed into the JupyterLab tool environment, since the kernel uses JupyterLab's Python interpreter. Packages installed elsewhere will not be importable inside the kernel.