jupyter-live-kernel

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

Updated May 26, 2026
One-click install
npx skills add https://github.com/ruiyangruiyi/hermes-agent --skill jupyter-live-kernel-ruiyangruiyi
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/ruiyangruiyi/hermes-agent/tree/main/skills/data-science/jupyter-live-kernel
Command: npx skills add https://github.com/ruiyangruiyi/hermes-agent --skill jupyter-live-kernel-ruiyangruiyi

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

You need an efficient way to run exploratory Python where variables, imports, and created objects persist across multiple steps, without rewriting everything into one long script.

Core Features & Use Cases

  • Stateful Python REPL via live Jupyter kernel: Keep the same runtime state across executions so iterative exploration feels natural.
  • Notebook-centric execution and editing: Execute code in a specific notebook, inspect variables, and modify notebook cells as your work evolves.
  • Live inspection for debugging and discovery: List and preview live variables to understand what the current kernel state contains.

Use case example: You are exploring a dataset and want to try feature engineering step-by-step, inspecting intermediate DataFrames and variables after each run, while keeping everything in a single persistent session.

Quick Start

Start a live kernel-backed REPL and execute incremental Python code against a scratch notebook so results and variables persist across steps.

Frequently Asked Questions about jupyter-live-kernel

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

FAQPage Schema
How do I keep Python variables and imports persistent across multiple code executions?

Use a live Jupyter kernel to execute Python statefully, allowing variables, imports, and created objects to persist across multiple steps without rewriting everything into a single script.

Can I inspect intermediate DataFrames step-by-step during data science exploration?

Yes, you can inspect DataFrames step-by-step during data science exploration by executing code in a live Jupyter kernel that lists and previews live variables after each run.

What is the best way to run ML prototyping code iteratively without losing kernel state?

Running ML prototyping code inside a live Jupyter kernel is the best way to maintain state, enabling incremental notebook-based development where earlier variables remain available across executions.

Do I need a uv environment to run a stateful Python REPL with a live Jupyter kernel?

Yes, a working uv environment and a running Jupyter server are required to use the stateful Python REPL, which uses the hamelnb workflow to manage servers, notebooks, and code execution.

How do I modify notebook cells and inspect variables in a persistent Python session?

You can modify notebook cells and inspect variables in a persistent Python session by using the hamelnb workflow to manage notebook cell editing and list live kernel state for debugging.

Why does my Python code lose variables when running exploratory data analysis step-by-step?

Variables are lost because standard execution lacks state persistence; a live Jupyter kernel solves this by keeping the same runtime state across executions so iterative exploration feels natural.