Metadata-Version: 2.4
Name: strata-notebook
Version: 0.6.0
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Programming Language :: Rust
Requires-Dist: pyiceberg[sql-sqlite,sql-postgres]>=0.8.0
Requires-Dist: pyarrow>=18.0.0
Requires-Dist: fastapi>=0.115.0
Requires-Dist: uvicorn>=0.35.0
Requires-Dist: websockets>=13.0
Requires-Dist: httpx>=0.28.0
Requires-Dist: duckdb>=1.1.0
Requires-Dist: python-multipart>=0.0.9
Requires-Dist: pydantic>=2.0.0
Requires-Dist: pydantic-settings>=2.0.0
Requires-Dist: tomli-w>=1.0.0
Requires-Dist: jsonschema>=4.0.0
Requires-Dist: infisicalsdk>=1.0.16
Requires-Dist: packaging>=24.0
Requires-Dist: filelock>=3.16.0
Requires-Dist: azure-storage-blob>=12.20.0 ; extra == 'azure'
Requires-Dist: azure-identity>=1.15.0 ; extra == 'azure'
Requires-Dist: mcp>=1.9.0 ; extra == 'mcp'
Requires-Dist: pandas>=2.0.0 ; extra == 'notebook'
Requires-Dist: numpy>=1.26.0 ; extra == 'notebook'
Requires-Dist: orjson>=3.10.0 ; extra == 'notebook'
Requires-Dist: cloudpickle>=3.0.0 ; extra == 'notebook'
Requires-Dist: matplotlib>=3.8.0 ; extra == 'notebook'
Requires-Dist: pillow>=10.0.0 ; extra == 'notebook'
Requires-Dist: opentelemetry-api>=1.20.0 ; extra == 'otel'
Requires-Dist: opentelemetry-sdk>=1.20.0 ; extra == 'otel'
Requires-Dist: opentelemetry-exporter-otlp>=1.20.0 ; extra == 'otel'
Requires-Dist: opentelemetry-instrumentation-fastapi>=0.41b0 ; extra == 'otel'
Requires-Dist: sqlglot>=25.0.0 ; extra == 'sql'
Requires-Dist: adbc-driver-manager>=1.0.0 ; extra == 'sql'
Requires-Dist: adbc-driver-bigquery>=1.0.0 ; extra == 'sql-bigquery'
Requires-Dist: duckdb>=1.0.0 ; extra == 'sql-duckdb'
Requires-Dist: adbc-driver-postgresql>=1.0.0 ; extra == 'sql-postgres'
Requires-Dist: adbc-driver-snowflake>=1.0.0 ; extra == 'sql-snowflake'
Requires-Dist: adbc-driver-sqlite>=1.0.0 ; extra == 'sql-sqlite'
Requires-Dist: textual>=0.80.0 ; extra == 'tui'
Requires-Dist: grandalf>=0.8 ; extra == 'tui'
Requires-Dist: textual-image>=0.13 ; extra == 'tui'
Requires-Dist: pillow>=10.0.0 ; extra == 'tui'
Provides-Extra: azure
Provides-Extra: mcp
Provides-Extra: notebook
Provides-Extra: otel
Provides-Extra: sql
Provides-Extra: sql-bigquery
Provides-Extra: sql-duckdb
Provides-Extra: sql-postgres
Provides-Extra: sql-snowflake
Provides-Extra: sql-sqlite
Provides-Extra: tui
License-File: LICENSE
Summary: A content-addressed computation graph with an interactive notebook UI
Keywords: notebook,materialization,provenance,lineage,reproducibility,content-addressed,iceberg,arrow,analytics
Author-email: Fangchen Li <fangchen.li@outlook.com>
License-Expression: Apache-2.0
Requires-Python: >=3.12
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Changelog, https://github.com/bearing-research/strata/blob/main/CHANGELOG.md
Project-URL: Documentation, https://bearing-research.github.io/strata/
Project-URL: Homepage, https://bearing-research.github.io/strata/
Project-URL: Issues, https://github.com/bearing-research/strata/issues
Project-URL: Repository, https://github.com/bearing-research/strata

# Strata

[![PyPI](https://img.shields.io/pypi/v/strata-notebook.svg)](https://pypi.org/project/strata-notebook/)
[![Python versions](https://img.shields.io/pypi/pyversions/strata-notebook.svg)](https://pypi.org/project/strata-notebook/)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/bearing-research/strata/blob/main/LICENSE)
[![CI](https://github.com/bearing-research/strata/actions/workflows/ci.yml/badge.svg)](https://github.com/bearing-research/strata/actions/workflows/ci.yml)
[![Pre-commit](https://github.com/bearing-research/strata/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/bearing-research/strata/actions/workflows/pre-commit.yml)
[![Docker](https://github.com/bearing-research/strata/actions/workflows/docker.yml/badge.svg)](https://github.com/bearing-research/strata/actions/workflows/docker.yml)
[![Docs](https://github.com/bearing-research/strata/actions/workflows/docs.yml/badge.svg)](https://github.com/bearing-research/strata/actions/workflows/docs.yml)
[![codecov](https://codecov.io/gh/bearing-research/strata/branch/main/graph/badge.svg?token=GBAX34U2PO)](https://codecov.io/gh/bearing-research/strata)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/bearing-research/strata/badge)](https://securityscorecards.dev/viewer/?uri=github.com/bearing-research/strata)

**Strata is a content-addressed computation graph with an interactive notebook UI.**

Every cell output is a versioned artifact keyed by its provenance: source,
inputs, and environment. Strata reads each cell's AST to build the
dependency graph automatically, so re-running a notebook is mostly a series
of cache hits. Touch one cell and the cascade re-executes only the cells
that depend on it. Identical inputs produce the same artifact whether the
second run comes a minute later or a year later, on the same machine or a
different one.

Prompt cells make AI calls first-class DAG nodes, cached by template,
inputs, and model config. `# @worker gpu-fly` dispatches a cell to a remote
GPU. `# @mount data s3://bucket/prefix ro` makes an S3 prefix available as a
local `pathlib.Path` inside the cell. The whole notebook is plain `.py`
files plus a manifest, so commits are git-diffable and there are no JSON
blobs or execution metadata bleeding into the history.

**Docs:** [bearing-research.github.io/strata](https://bearing-research.github.io/strata/)

## Give your coding agent a cached scratchpad

Coding agents explore by writing throwaway `python -c` and `/tmp` scripts:
invisible, uncached, redone every session. Point one at Strata instead and it
uses a **persistent, cached notebook** as its scratchpad: every snippet becomes a
content-addressed cell, so the expensive step it ran ten turns ago is still a
cache hit now, a human can watch it work live, and the work is a git-diffable
directory instead of discarded scripts.

Install it as a one-command [Claude Code plugin](plugins/strata-scratchpad/)
(needs the `strata` CLI on `PATH`; `uv tool install strata-notebook`):

```
/plugin marketplace add bearing-research/strata
/plugin install strata-scratchpad@strata
```

<!-- Demo GIF slot. Record with examples/agent_demo/RECORDING.md, save to
     docs/assets/agent-demo.gif, then uncomment the line below:
![A coding agent builds a Strata notebook live; the model stays cached when only the evaluation changes](docs/assets/agent-demo.gif)
-->

Does the agent reach for it instead of a scratch script? There's an eval
that measures exactly that (`evals/agent_notebook/`): in the un-primed sessions
tested so far it reaches for the notebook every time, and building the eval
caught real bugs. Small sample, and honest about it. See
[Driving a notebook with a coding agent](https://bearing-research.github.io/strata/notebook/agent/).

## Highlights

- **agent scratchpad:** a Claude Code plugin makes a coding agent use a cached notebook cell for throwaway Python instead of `/tmp` scripts - one-call add-and-run, and unchanged work is never recomputed
- **remote cells over SSH (0.6.0):** hand a coding agent an SSH target and it provisions a `strata-worker` on the box, opens a secure tunnel, and routes heavy cells there, cached by provenance like everything else - `connect_ssh_worker` in-tool or `strata agent --worker-ssh user@host`, with `# @worker local` to keep a cell on this machine
- **content-addressed:** every cell output is keyed by source + inputs + environment - identical work hits the cache forever
- **reactive:** edit a cell, the cascade re-runs only the downstream cells that depend on it
- **dag-from-ast:** Strata reads each cell's AST to wire upstream/downstream - no decorators, no manual edges
- **dag-view:** the dependency graph renders alongside the cells - double-click any node to jump to its source
- **ambient client (0.3.0):** every cell gets a ready `strata` client in its namespace - publish and consume artifacts across cells with no boilerplate
- **registry in the UI (0.3.0):** promote and approve named artifacts from a notebook dashboard - pending-approval queue, alias chips, and `model ← features ← scan ← table` lineage
- **git-friendly:** notebooks are plain `.py` files plus a TOML manifest - readable diffs, no JSON blobs
- **prompt cells:** LLM calls are first-class DAG nodes, `{{ variable }}` interpolation from upstream cells, cached by template + inputs + model config
- **SQL cells:** named connections, bind-parameter templating, drivers for DuckDB / SQLite / Postgres / Snowflake / BigQuery
- **R cells (0.2.0):** Python and R cells share a DAG; cross-language Arrow exchange means a `pandas.DataFrame` is a `data.frame` for the next cell. First-class in the UI - Add-R-cell menu, an R environment panel with one-click renv bootstrap + package install, automatic `renv::restore()` on open, and inline plots (ggplot2 / base graphics render to PNG). Runs headlessly too - `strata run` executes R cells for CI
- **loop cells:** `# @loop max_iter=N carry=state` iterates a cell with explicit carry between steps - each iteration is its own artifact
- **variant sweep (0.4.0):** a variant group can run in sweep mode - every variant executes and the downstream cell receives a `{variant_name: value}` dict, for comparing models / hyperparameters / prompts side by side in one cell (switch mode runs only the active variant)
- **cell unit tests (0.4.0):** a 🧪 Tests panel on any Python cell runs **real pytest** against the cell's defs and upstream inputs (`def test_x(cell): assert cell.featurize(cell.trips)…`) - assertion rewriting, fixtures, and parametrize all work; the toggle doubles as a health badge (`✓ 4/4`, red on fail, `· stale` when the cell changed)
- **MCP server (0.5.0):** expose a running notebook session to an external coding agent (Claude Code, any MCP client) at `/mcp` - the agent reads, runs, authors, and manages dependencies against a **warm session**, and you watch it happen live in the browser or the terminal viewer. `claude mcp add --transport http strata http://localhost:8765/mcp`. Personal-mode only, behind the `[mcp]` extra
- **interactive widgets + app view (0.5.0):** a `widget` cell is a declarative control panel (slider / number / dropdown / checkbox / text); each control is an input downstream cells consume, and with **⚡ Live** on, dragging one recomputes the cells that depend on it. Open a notebook as a read-only **app** (`/app/<id>`), **embed** that app view in another site as an `<iframe>`, or export a frozen, self-contained **snapshot** (`strata export --app-view`)
- **interactive data viewer (0.5.0):** DataFrame outputs render in a grid you can page, sort, filter, and search - backed by the full cached artifact, not a 20-row preview - with CSV / Parquet export (in the web UI and the terminal viewer)
- **per-variant fan-out (0.5.0):** `# @per_variant` runs a cell once per variant of a sweep group - each variant its own artifact, cache entry, and worker dispatch, so adding a variant only runs the new instance
- **terminal viewer (0.4.0):** `strata-notebook-tui` attaches to a running notebook and renders it live in the terminal - cells flip status as they run, syntax-highlighted source, tables and markdown rendered, a layered DAG view (`d`), and an Agent tab that streams an AI agent's reasoning as it drives the notebook. Read-only - watch an agent (or a run-all) work in one terminal from another. Ships behind the `[tui]` extra (`uv tool install "strata-notebook[tui]"`)
- **agent CLI (0.4.0):** the `strata` command drives a notebook end to end - inspect (`cell list/show`, `dag`, `status`), run one cell at a time (`cell run/test`), and author (`cell add/edit/rm/mv`, `cell annotate`, `dep add/rm`) - all with `--format json` and stable exit codes. Works **offline against a notebook directory or against a live session on a running server** (`--server/--session`), so an agent builds and runs a notebook the same way whether or not a server is up
- **agent on-ramp:** `strata agent ./nb` is one command that stands up an MCP-enabled server, opens a session, writes `.mcp.json` + a `CLAUDE.md` working agreement, and attaches the terminal viewer - point a coding agent (Claude Code) at a live notebook and watch it build cells. The notebook doubles as the agent's **persistent, cached scratchpad**: unchanged cells (even a leaf cell that only `print`s) replay instantly instead of recomputing, so exploration is captured and watchable instead of thrown away in `/tmp`. A cell whose point is a side effect or a fresh value opts out with `# @nocache`
- **distributed:** `# @worker gpu-fly` dispatches a single cell to a remote box - bring your own compute
- **mounts:** `# @mount data s3://bucket/prefix ro` makes any S3 / GCS / Azure prefix a local `pathlib.Path`
- **isolated envs:** every notebook gets its own uv-managed `.venv/`, locked and reproducible
- **auto-install:** missing import in a cell? one click adds the package via uv and re-runs
- **headless:** `strata run ./my-notebook` for CI and scheduled execution - same DAG, same cache
- **also a library:** the materialization layer is exposed via HTTP + a `StrataClient`, usable from any Python process
- **slim client package (0.3.0):** `pip install strata-client` pulls only httpx + pyarrow - use the store from any pipeline or service, no server install
- **production-ready:** Iceberg-aware scans, trusted-proxy auth, multi-tenancy, S3 / GCS / Azure / local blob backends

## Quick Start

Both paths below run in **personal mode**: single-user, writes enabled, no
proxy auth. For multi-tenant or hosted deployments, see
[Deployment Modes](https://bearing-research.github.io/strata/deployment/modes/).

```bash
# Docker. docker-compose.yml sets personal mode for you.
docker compose up -d --build
# Then open http://localhost:8765

# Or install via uv (recommended). Fetches the wheel from PyPI into a
# uv-managed tool env at ~/.local/share/uv/tools/strata-notebook with
# the CLI on PATH. Plain `pip install` is not supported - Strata refuses
# to start outside a uv-managed env (see Requirements below).
uv tool install strata-notebook
strata-notebook
# Then open http://localhost:8765
```

For the full inventory of installed commands (`strata-notebook`, `strata`,
`strata-worker`, `python -m strata`), see the
[Commands reference](https://bearing-research.github.io/strata/getting-started/installation/#commands-reference).

Source builds - `git clone + uv sync` - work too and are documented in
[Installation](https://bearing-research.github.io/strata/getting-started/installation/);
needed only if you're modifying Strata itself.

### Requirements

- **[uv](https://docs.astral.sh/uv/) ≥ 0.8** - install via the
  [uv installer](https://docs.astral.sh/uv/getting-started/installation/)
  (`curl -LsSf https://astral.sh/uv/install.sh | sh` on macOS/Linux;
  PowerShell installer on Windows). Strata refuses to start outside
  a uv-managed environment: the startup check looks for the
  `uv = <version>` marker that uv writes to `pyvenv.cfg`. `uv tool
  install`, `uv add`, and `uv run` all produce envs with this
  marker; plain `pip install` into a hand-rolled `python -m venv`
  does not, and Strata will refuse to start there. Conda and
  pip-venv users need to install uv and re-launch from a uv-managed
  env - existing data and other environments are untouched. uv
  fetches a matching Python for you, so you don't need Python
  pre-installed.

Source build (only if you're building Strata itself from a git clone,
not using PyPI or Docker):

- **[Rust toolchain](https://rustup.rs/)** (rustup) - for `maturin`
  to compile the native extension. PyPI wheels skip this step.
- **[Node 26+ / npm](https://nodejs.org/)** - for the frontend
  `npm ci && npm run build` step. PyPI wheels bundle the prebuilt SPA.
- Python 3.12+ is handled automatically by `uv sync`.

Windows: `uv tool install strata-notebook` works directly. Source builds
work via WSL2 (smoother) or native Windows (uv + rustup + Node have
Windows installers).

Why uv at runtime: the notebook subsystem shells out to `uv` to
manage per-notebook `.venv/` directories, and the project's dev
workflow assumes uv as the install path. Failing fast at startup with
a clear message beats a confusing subprocess error later.

## The Cache Advantage

Every notebook platform re-executes from scratch when you change one cell.
Strata doesn't. The artifact store deduplicates by provenance hash. If
the code and inputs haven't changed, the result is served instantly.

```
First run:     load data (10s) → clean (3s) → train (20s) → evaluate (1s)  = 34s
Change model:  load data (✓)   → clean (✓)  → train (20s) → evaluate (1s)  = 21s
Re-run:        load data (✓)   → clean (✓)  → train (✓)   → evaluate (✓)   = <1s
```

This isn't a feature bolted on. It's the architecture. Every cell
execution is a `materialize(inputs, transform, environment) → artifact` operation,
and the cache is correct by construction because it's keyed on content,
not time.

Even a leaf cell that only `print`s is cached: its console output is keyed
by the same provenance hash, so an unchanged re-run replays the output
instantly rather than executing again. That makes the notebook a good
**scratchpad** - a coding agent's exploratory snippets stop recomputing.
Cells that must always run (a side effect, a live API call, a fresh random
draw) opt out with `# @nocache`.

## Distributed Execution

Each cell can declare which worker it runs on via a single annotation:

```python
# @worker my-gpu
embeddings = model.encode(abstracts, batch_size=256)
```

You define workers in `notebook.toml`. Each one points at an HTTP
endpoint that implements the Strata executor protocol. A worker can be
a GPU box on RunPod, a DataFusion cluster on Fly, a beefy EC2 instance,
or anything else that speaks HTTP. The notebook routes the cell to the
declared worker at execution time, and the UI shows a live
"dispatching to my-gpu" badge while it runs.

No deployment code, no infrastructure glue. Bring your own compute,
one annotation per cell.

## Source Annotations

Every piece of per-cell metadata is a comment directive in the cell's
source. The source is the single canonical place for cell config:
annotations always win over any stored defaults.

```python
# @name Extract embeddings
# @worker gpu-fly
# @timeout 600
# @env MODEL_PATH=/models/bge-large
# @mount dataset s3://corpus/2024-q4 ro
embeddings = model.encode(dataset / "abstracts.jsonl")
```

Diagnostics fire on open, reload, and after an edit settles:
`worker_unknown`, `mount_uri_unsupported`, `mount_shadows_notebook`,
`timeout_not_numeric`, `env_malformed`. They surface as a pill in the
cell header and log structured warnings for headless runs.

## Mounts

Mounts bind a remote URI to a local path inside the cell. Supported
schemes: `file://`, `s3://`, `gs://`, `az://`. Credentials flow through
fsspec options: set `anon = true` for public buckets, or drop it to
use the standard credential chain.

```toml
[[mounts]]
name = "taxi_zones"
uri = "s3://nyc-tlc/misc"
mode = "ro"
options = { anon = true }
```

Inside the cell, `taxi_zones` is a `pathlib.Path`. Strata materializes
it on first read and caches the bytes locally for the session.

## Examples

| Example                                             | What it shows                                                                       |
| --------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [pandas_basics](https://bearing-research.github.io/strata/examples/pandas_basics/)             | Linear DataFrame chain, caching, staleness propagation, per-cell unit tests          |
| [iris_classification](https://bearing-research.github.io/strata/examples/iris_classification/) | End-to-end ML, DAG branching, mixed output types                                    |
| [titanic_ml](https://bearing-research.github.io/strata/examples/titanic_ml/)                   | Feature engineering + model comparison                                              |
| [s3_mount](https://bearing-research.github.io/strata/examples/s3_mount/)                       | Reading a public S3 bucket via a mount                                              |
| [arxiv_classifier](https://bearing-research.github.io/strata/examples/arxiv_classifier/)       | Distributed execution via `@worker` + Modal GPU + Fly cluster                       |
| [markdown_showcase](https://bearing-research.github.io/strata/examples/markdown_showcase/)     | Markdown cells, dynamic `Markdown(...)` outputs, security cases                     |
| [library_cells](https://bearing-research.github.io/strata/examples/library_cells/)             | Cross-cell library code: pure module cells, mixed runtime+library cells, the limits |
| [news_alpha_trader](https://bearing-research.github.io/strata/examples/news_alpha_trader/)     | Multi-stage trading pipeline with prompt cells and structured LLM outputs           |
| [review_triage](https://bearing-research.github.io/strata/examples/review_triage/)             | Prompt cell with `# @output_schema` - structured, schema-validated LLM output       |
| [r_mtcars_analysis](https://bearing-research.github.io/strata/examples/r_mtcars_analysis/)     | Pure-R notebook - `mtcars` regression with inline ggplot2 / base-graphics plots     |
| [r_lm_vs_sklearn](https://bearing-research.github.io/strata/examples/r_lm_vs_sklearn/)         | Cross-language R + Python - R `lm()` vs scikit-learn over shared Arrow data          |
| [sql_orders_report](https://bearing-research.github.io/strata/examples/sql_orders_report/)     | SQL cells over a local SQLite warehouse, mixing SQL / Python / markdown              |
| [widget_playground](https://bearing-research.github.io/strata/examples/widget_playground/)     | Widget cell (control panel) driving a downstream cell, with `# @live` reactivity     |
| [model_variants](https://bearing-research.github.io/strata/examples/model_variants/)           | Variant groups - alternative training cells sharing one DAG slot (switch mode)       |
| [model_variants_sweep](https://bearing-research.github.io/strata/examples/model_variants_sweep/) | Variant sweep mode - run every variant and compare them in one downstream cell     |
| [loop_hill_climb](https://bearing-research.github.io/strata/examples/loop_hill_climb/)         | `# @loop` / `# @loop_until` iteration with carry and per-iteration artifacts         |
| [data_viewer](https://bearing-research.github.io/strata/examples/data_viewer/)                 | Interactive data viewer - page / sort / filter / search the full cached artifact     |
| [agent_demo](https://bearing-research.github.io/strata/examples/agent_demo/)                   | A coding agent builds the notebook live; only the eval re-runs when the model caches |

## Known rough edges

Strata is young and a few surfaces are explicitly exploratory. The core
(materialization, artifact store, DAG, caching, headless run) is stable
in the alpha sense; these are the bits where the API or coverage is
still moving:

- **Prompt-cell API.** Streaming, conversation memory, and structured-output
  validation are not yet finalized - expect breaking changes in 0.x.
- **SQL cell cloud drivers.** DuckDB / SQLite / PostgreSQL are exercised
  in CI. BigQuery and Snowflake adapters ship but lack integration test
  coverage; pin a Strata version in production until that lands.
  MotherDuck and MySQL are planned but not yet implemented.
- **Wire / on-disk formats.** `notebook.toml`, `.strata/runtime.json`, and the
  artifact cache layout may change between minor versions during 0.x.
  Rely on the Python API surface, not the file shapes.

---

## Library usage

Strata's HTTP API exposes the materialization layer directly,
driveable from Python via `StrataClient`. Useful for direct table
scans, custom transforms, and headless workflows; the notebook
executor is a separate pipeline that writes to the same artifact
store. The client talks to a running Strata server, so this workflow
has two steps: start the server, then call it from your code.

```bash
# 1. Install + start the server (in a uv-managed env).
uv tool install strata-notebook
strata-notebook

# 2. In your own project, install the slim client - a separate package
#    (httpx + pyarrow only, no server deps, plain pip is fine) - and
#    point it at the running server:
pip install strata-client
```

```python
from strata_client import StrataClient

client = StrataClient(base_url="http://localhost:8765")
artifact = client.materialize(
    inputs=["file:///warehouse#db.events"],
    transform={"executor": "scan@v1", "params": {"columns": ["id", "value"]}},
)
table = client.fetch(artifact.uri)  # Arrow table, cached by provenance
```

The server provides: provenance-based deduplication, immutable
versioned artifacts, lineage tracking, Iceberg table scanning with
row-group caching, pluggable blob storage (local/S3/GCS/Azure),
multi-tenancy, trusted-proxy auth, and an executor protocol for
external compute.

**[Library docs →](https://bearing-research.github.io/strata/getting-started/core/)**

---

## Architecture

```
┌─────────────────────────────────────────────┐
│ Notebook UI (Vue.js + WebSocket)            │
│ cells, DAG view, AI assistant, workers      │
└─────────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────┐
│ Notebook Backend (FastAPI)                  │
│ session, cascade, executor, prompt cells    │
└─────────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────┐
│ Strata Core                                 │
│ materialize, artifacts, lineage, dedupe     │
└─────────────────────────────────────────────┘
```

The notebook is an orchestration layer over Core. It decides what to
run next (cascade planning, staleness tracking). The cell harness is an
executor. Core decides whether results already exist and persists them.

## Development

```bash
uv sync --all-extras                   # Install deps + build Rust extension (matches CI)
uv run pytest                          # Run all tests
uv run pre-commit run --all-files      # Lint + format
cd frontend && npm run dev             # Frontend dev server (hot reload)
```

## License

Apache 2.0

