skills.rest
musical-basics
musical-basicsCOMMUNITY
Explore all skills by this author →
GitHub

jupyter-live-kernel

Execute Python code iteratively with persistent state via a live Jupyter kernel.

Updated Apr 11, 2026
Search Tags:#python#interactive#repl#kernel#jupyter#data-science#hamelnb
One-click install
npx skills add https://github.com/musical-basics/hermes-build-2 --skill jupyter-live-kernel-musical-basics
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/musical-basics/hermes-build-2/tree/main/skills/data-science/jupyter-live-kernel
Command: npx skills add https://github.com/musical-basics/hermes-build-2 --skill jupyter-live-kernel-musical-basics

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Iterative data exploration and experimentation often require a persistent Python environment so variables, imports, and intermediate results survive across multiple executions; this skill provides a live Jupyter kernel interface to support that workflow.

Core Features & Use Cases

  • Persistent REPL: Execute Python code incrementally with variables and state preserved between runs.
  • Notebook management: Discover servers and notebooks, edit cells, list and preview live variables, and restart-and-run-all for verification.
  • Use Cases: Ad-hoc data analysis, machine learning experimentation, API exploration, debugging complex code, and building up examples step-by-step using a scratch notebook.

Quick Start

Start a headless JupyterLab server and use the hamelnb execute command against scratch.ipynb to iteratively run Python code and inspect live 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 keep Python variables and state persistent across multiple executions?▼

You can execute Python code iteratively using a live Jupyter kernel, which preserves variables, imports, and intermediate results across multiple runs. Start a headless JupyterLab server and use the hamelnb execute command against scratch.ipynb to run code and inspect live variables.

What is a stateful Python REPL used for in data science workflows?▼

A stateful Python REPL supports ad-hoc data analysis, machine learning experimentation, API exploration, and incremental debugging. It allows you to build up examples step-by-step using a scratch notebook where kernel state persists across cell-level executions.

Can I manage and edit Jupyter notebook cells during an active Python session?▼

Yes, you can discover servers and notebooks, edit cells, list and preview live variables, and perform restart-and-run-all for verification. Session management is handled via the hamelnb CLI to maintain your persistent kernel state during exploratory workflows.

How do I start an interactive Python session for incremental debugging?▼

Start a headless JupyterLab server and use the hamelnb execute command against a scratch.ipynb file. This provides a live kernel interface to iteratively run Python code, inspect live variables, and debug complex code step-by-step with configurable execution timeouts.

Are there execution timeout limits when running code through a live Jupyter kernel?▼

Yes, the live Jupyter kernel interface supports configurable execution timeouts for running Python code. This ensures long-running exploratory workflows or stuck operations can be managed appropriately during iterative data analysis sessions.

Related Skills

Explore More Data & Analytics Skills→
JKhyroJKhyro

jupyter-live-kernel

Execute stateful Python code in a live Jupyter kernel.

Community
Intermediate
AubreyHanAubreyHan

notebook-guidance

Organize and validate Jupyter notebook workflows for data analysis and BigQuery investigations.

Community
Advanced
slantviewslantview
1

data-scientist

Perform end-to-end data science tasks with pandas, scikit-learn, and plotly.

Community
Advanced
gztcodegztcode

jupyter-live-kernel

Execute Python code with a live Jupyter kernel preserving state between runs.

Community
Advanced