Dandelion

Dandelion is a notebook where the AI is a thinking partner, not a ghostwriter. You work in small steps, writing and running every cell yourself, and the AI asks a guiding question or gives a hint when you need one. It looks like the Claude desktop app, runs on your laptop, and switches to a remote GPU from a dropdown without changing how you work.

Why Dandelion

• The AI hints; you run the code. In learning mode, the default, an answer is a nudge, not the finished solution. When you ask, it can edit a cell you can see ("fix cell 3"), but it never runs a cell, and by default it can't write files or work off-screen.
• A real notebook underneath. Code runs in a persistent Python kernel, with completion from the live namespace, inline plots and DataFrames, linkable cells and Jupyter keys. The AI sees the cells above your question, so "why is this slow?" gets a real answer.
• Yours, wherever it runs. Notebooks, papers and libraries live in ~/.config/dandelion, never in git, and the front end loads nothing from a CDN. The same notebook runs against your laptop or an H100 through an SSH tunnel.

Quick start

You need uv and just (brew install uv just).

git clone https://github.com/slegroux/dandelion.git && cd dandelion
uv sync --extra kernel --extra paper --extra web   # the app, the kernel's numpy/torch stack, PDF + web readers
just start                                         # kernel on :5055, UI on http://localhost:8000

just stop stops both, and just app builds a double-clickable Dandelion.app. The LED in the top-right should be green: the UI has reached the kernel and code runs for real. Amber means it fell back to an in-memory demo; just doctor tells you why.

Then choose how Ask AI reaches a model, in ⚙ Settings:

Route	You need	Billed
Claude subscription (Pro / Max)	the claude CLI, signed in (claude auth login; make it last)	your plan
ChatGPT subscription (Codex)	the codex CLI, signed in (codex login)	your plan
Claude API or GLM	an API key, pasted in Settings	per token

A first dialog

A dialog is a column of cells: notes (markdown), code, and Ask AI prompts. Here is the loop, end to end.

1. Write code and run it. Variables persist between cells, as in Jupyter.

import numpy as np
sr, f0 = 8000, 100
t = np.arange(sr) / sr
sq = np.sign(np.sin(2 * np.pi * f0 * t))     # one second of a 100 Hz square wave

2. Ask, and get a nudge. Put $`expr` in a prompt and the AI receives its live value, computed fresh each time you ask:

Why does a square wave only have odd harmonics? Don't give me the answer. My signal is $`sq.shape` samples long.

It answers with a hint and a check you can run, then leaves the next step to you.

3. Let it edit, when you ask. Every cell has a number in its gutter. "Vectorise the loop in cell 4" rewrites that cell in place, and the new code waits there until you press Run.

4. Read a paper beside your notebook. Click 📄 and paste arxiv.org/abs/1706.03762: the PDF becomes structured text with equations, tables and figures. Highlight a passage, click → Notebook, and it arrives as a note with an empty code cell below it for your version.

5. Ship what you learned. Tag cells, from any dialog, into a Python package:

#| export audiolib:layers        # this cell goes to library `audiolib`, module `layers`
class Conv1d: ...

uv run python -m dandelion.cli library build audiolib ./audiolib   # nbdev tangles it into a package

Click Use in kernel, and import audiolib works in any cell. Each generated function links back to the cell you wrote it in.

Features

Editable cells	Rendered by default, click to edit; headings fold into sections
Linked cells	#_<id> links within and across dialogs; the AI can cite cells too
Live completion	From what you've actually run, via jedi
Live values in prompts	$`df.shape` sends the real number
Context you can see	Per-cell token counts; mute a cell to drop it, pin one to keep it
Three modes	learning, concise, standard
Cell edits, not an agent	Visible, in-notebook edits only; Write, Edit and Bash denied
Rich output	Matplotlib, _repr_html_ and _repr_png_, inline
Jupyter keys	Command and edit modes, /, /, ,

Laptop or H100

A target is just the server URL the client points at, defined in targets.yaml. For a remote GPU, run the bundled kernel server there and tunnel it back. The URL stays on localhost, and the port never touches the public internet:

uv run python -m dandelion.cli up h100        # open the SSH tunnel
uv run python -m dandelion.cli doctor h100    # DNS, port, token, route: exactly what's broken

Then switch targets from the dropdown in the top bar. Code runs on the bundled kernel server by default; with the solveit extra, Dandelion can instead connect to a SolveIt server through Answer.AI's solveit_client. See the guide.

Development

just test     # the suite runs offline: no server, subprocess or network
just lint
just dev      # kernel + UI in the foreground; Ctrl+C stops both

Path	What it is
dandelion/app.py	The FastHTML UI: server-side rendering, htmx swaps
dandelion/client.py	One connect() over the bundled kernel, solveit_client and an in-memory mock
server/kernel_server.py	The kernel server: execution, rich output, completion
dandelion/claude_cli.py, codex_cli.py	Ask AI over your Claude or ChatGPT subscription
site/	The landing page

Renamed from Pappus (and before that, SolveIt Sidekick). On first start, Dandelion moves your data from ~/.config/pappus to ~/.config/dandelion and leaves a link at the old path; converted papers keep their cache. PAPPUS_* and SIDEKICK_* settings still work as their DANDELION_* equivalents. Notebook code that imported pappus.* modules now imports dandelion.*.