jupyter-live-kernel

Execute Python code against a persistent live Jupyter kernel.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

It solves the problem of having to repeatedly restart or rewrite code when you want to explore ideas and data step-by-step, because it provides a persistent, stateful Python environment.

Core Features & Use Cases

  • Stateful execution across steps: Run Python incrementally so variables, imports, and objects persist between executions, enabling true iterative development.
  • Notebook-aware exploration and editing: Discover available servers/notebooks, execute code in a live kernel, inspect variables, and edit notebook cells when you need to adjust logic.
  • Verification via restart-and-run-all: Restart the kernel and run all cells to confirm the notebook executes cleanly top-to-bottom.

Use Case: You are investigating a dataset and repeatedly transforming a DataFrame—use the live kernel to keep your working objects, inspect intermediate results, and then edit the notebook cells without losing state.

Quick Start

Start a live Jupyter kernel session, create a minimal scratch.ipynb if needed, and iteratively execute your Python code against the same persistent environment to inspect results as you go.

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 iteratively without losing variables in a Jupyter notebook?

By executing Python against a live Jupyter notebook kernel, your variables and objects persist across multiple calls, enabling true stateful execution and incremental debugging without restarting.

Can I inspect and edit notebook cells while doing exploratory data analysis?

Yes, you can inspect variables, preview DataFrames, and edit notebook cells via the hamelnb interface during exploratory data analysis to adjust logic without losing your working state.

Do I need a local Jupyter server running to use a stateful Python REPL?

Yes, you need a reachable local Jupyter server and a live kernel session, along with uv and JupyterLab tooling installed, to execute code against the persistent notebook environment.

What's the best way to verify a notebook executes cleanly top-to-bottom?

The best way to verify clean top-to-bottom execution is the restart-and-run-all feature, which restarts the Jupyter kernel and runs all notebook cells sequentially to confirm logic integrity.

Why does my Python REPL reset variables when I run data analysis step-by-step?

Variables reset in standard execution because it lacks stateful persistence; running your code against a live Jupyter notebook kernel instead keeps objects, imports, and DataFrames intact between calls.