jupyter-live-kernel

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

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires jupyterlab, uv.

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 attempt. 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 Jupyter kernel where variables, imports, and objects persist across executions. - Variable Inspection: List and preview live kernel variables to inspect DataFrames, models, 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 execution. - Use Case: While exploring a new dataset, load it into a pandas DataFrame once, then iteratively filter, plot, and transform it across many executions without reloading, and finally verify the full notebook runs cleanly. ## Quick Start Start a JupyterLab server, create a scratch notebook session, then ask the agent to execute Python code in the notebook 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: execute code against a notebook session and variables, imports, and objects persist across calls. This avoids reloading data or re-importing libraries on every run.

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

Use a Jupyter kernel for iterative exploration, data science, and tasks where state must persist across steps. Use one-shot execution for stateless scripts that need tool access like web search or file operations.

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 code can execute.

Why does the first code execution against Jupyter 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 --timeout 120 for heavy operations.

Can I inspect DataFrame variables in a running Jupyter kernel?▼

Yes, the variables command lists all live kernel variables and the preview option shows a specific variable's contents by name. This lets you inspect DataFrames and objects without re-executing code.