Plixlab Docs

Plixlab is a computational medium for interactive storytelling: presentations whose charts, pictures and 3D models are computed by live code. You build them by talking to your own AI assistant through the Plixlab connector, or by hand in the app.

Quick start

1. Create an account.
2. Add Plixlab to your AI assistant (Claude, ChatGPT, Claude Code or Copilot) with the connector URL https://mcp.plixlab.com. See Connect your AI assistant.
3. Ask for a presentation, for example: “Make a Plixlab deck on the damped harmonic oscillator with a live plot and an input for the damping ratio.”
4. Open the link your assistant returns. Edit anything on the canvas, change an input and press Run.

Connect your AI assistant

Plixlab is an MCP server. Your assistant signs in to your Plixlab account once (OAuth) and can then create slides, write and run code cells, lay out elements and read your presentations. It runs on your own assistant subscription. Plixlab has no built-in chat and charges no AI credits.

The same settings are in the app under Account → MCP Connector, which opens by itself on your first sign-in.

Claude (claude.ai and desktop)

Customize → Connectors → Add custom connector, name it Plixlab, pastehttps://mcp.plixlab.com and connect.

Claude Code

claude mcp add --transport http plixlab https://mcp.plixlab.com

ChatGPT

Turn on Developer mode, then Settings → Connectors → Create and paste the URL. Developer mode is available on ChatGPT's paid plans.

GitHub Copilot (VS Code)

Use the Add button in Account → MCP Connector, or add an HTTP MCP server named plixlab with the URL above.

Any other MCP client that supports remote HTTP servers with OAuth works the same way.

What is in a presentation

A presentation is one unit that travels together: its slides, its compute pipeline, and the rows (datasets, pictures, movies, models) its cells read and write. Duplicating, sharing or importing a presentation copies all of it, so a copy never depends on the original.

Each presentation has two views, switched at the top: Slide view for the deck, and Pipeline view for the code graph behind it.

Slides and elements

Slides are 16:9. Elements come in two kinds.

• Self-contained: text and shapes.
• Row-backed: an element that shows a row, drawn according to what the row is. A chart is live and interactive, a picture is an image, a video plays, and a 3D model opens in a viewer. A number shows as a value tile, a dict of numbers as a box, and columns as a table. When a Run rewrites the row, the element redraws.

Double-click a value tile to edit the number in it. Then press Run to recompute everything downstream.

Pipeline, cells and rows

A presentation has one pipeline: the graph of its Python code cells. Every port of a cell is bound to a row of the presentation (an uploaded asset or a computed output); the left rail's Sources lists the rows no cell computes.

• Each output port writes its own row, created empty when you add the output. After a Run the row holds the value, so you can read it, put it on a slide or feed it to another cell.
• An input port reads a row that exists: drag a source from the Sources list, or another cell's output port, onto a cell to add an input bound to it. Two cells are wired when an output of one and an input of the other name the same row. Click a port to open its row.
• A row's kind is fixed when it is created; every port on the row shares it.
• A cell sees exactly the Python object of each input's kind (see What a cell returns). What it assigns to an output port is what the next cell receives.
• Keep cells self-contained. A cell depends only on importable packages and its ports. Bring data in as rows, not as file paths.
• A cell is a function of your account, used once in a presentation. A presentation can also read a row that another presentation computes: it changes when that presentation runs.

Running

Nothing executes until you press Run (or your assistant calls run). A Run executes the whole presentation as one graph in dependency order. Cells whose code, inputs and environment have not changed replay from cache, so re-running after a plot tweak costs only the plot cell. Each cell's log is in the Pipeline view, and Stopcancels a run.

Keep computing and plotting in separate cells: a compute cell emits numbers, and a plot cell turns them into a figure. Then styling changes never re-run the expensive step.

What a cell returns

Every port has a kind: an input takes its row's, an output's is picked when it is added (Add output on the cell, or kind on the port over MCP). It is shown as the Python type in the cell's def header. The cell returns that object on an output and receives it on an input; a value of another type is refused at the port.

A DataFrame or a matplotlib figure is converted in the cell:{c: df[c].to_numpy() for c in df} on a csv output, orfig.savefig(buf, format="png") and Image.open(buf) on an image one.

A row is a file

Every row is one file, stored exactly as it was written, and its kind is the format of that file. Nothing converts it: what you upload is what a cell reads, and what a cell writes is what you download.

Data has three kinds. Pick by what the value is:

• yaml: values. A number, a string, a list, a dict of them: a parameter, a configuration, a small result. An integer stays an integer and a float a float.
• csv: a table. Columns of one length under a header row. Every number column is read as float64; a cell that needs integers casts the column.
• h5: arrays. NumPy arrays of any rank and dtype in a dict (an HDF5 file). Use it for anything large or N-dimensional.

You edit a yaml, csv or h5 row in its card; the file is rewritten as it is (an array keeps its dtype). A yaml or a csv row is text, so an assistant reads and writes it directly; any other row is a file your assistant downloads, changes and uploads back in place of the old one. A row a cell writes is rewritten by its next run.

Sweeps

An asset can hold several samples, for example several measurements or parameter sets (its ⋮ menu: Add a sample) — a sweep. Every Run then executes the cells reading it once per sample (once per pair when two assets sweep), and each output keeps one row per combination, named output/sample (output/a/b with two sweeps).

• Pick which sample the deck shows from the left rail's samples section (click it). The plixes' inputs and outputs, the cards and the slides follow; a slide element placed on one combination's row stays on it, so two can sit side by side.
• Exclude a sample (its ⋮ menu) to leave it out of every Run.
• A cell set to Collect inputs (its ⋮ menu) reads every sample of a swept asset as a single dict keyed by sample and runs once after them, for example to overlay every sample in one chart.
• Reuse an asset or a plix in another deck with Copy (its ⋮ menu) and Paste (the plixes header): a copy of its own — the same files, the plix's code and ports.

Where code runs

Each cell runs on a runner, chosen through its environment (see below). There are three:

• Cloud-CPU (Plixlab Cloud) runs on our servers, with no tab needed. It is a pinned Python image with NumPy, SciPy, pandas, Plotly, scikit-learn, statsmodels, SymPy, NetworkX, xarray, Polars, Shapely, h5py, PyTorch (CPU) and JAX (CPU). It uses your Pro plan's cloud compute hours.
• Cloud-GPU is Cloud-CPU with one NVIDIA L4 GPU (24 GB): the same image with the CUDA builds of PyTorch and JAX. One hour of it uses 15.4 compute hours.
• Browser runs Python in your own tab through Pyodide (WebAssembly), for free. It has the same scientific stack minus PyTorch and JAX, plus pure-Python packages from PyPI. It runs only while the presentation is open in a tab.

An environment's card (left rail → Compute) shows its runner and the packages that come with it.

Environments and packages

An environment belongs to your account: the same list in every presentation. It names a runner, extra packages and environment variables. Each cell picks an environment in its menu (⋮ → Environment) in the left rail. Every account has three built-in environments, Cloud-CPU, Cloud-GPU andBrowser. Create your own when a cell needs a package its runner lacks:

• Packages are PyPI names or public GitHub repositories.
• Environment variables are seen by the people you share a presentation using them with, so never put a secret there.
• Extras install on top of the runner's base packages as a pinned layer, so results stay reproducible and the base never changes.
• Changing an environment changes it in every presentation using it: its cells' cache is invalidated, so they re-run on the next Run.

Uploading files

Add rows from the Pipeline view or the left rail, or ask your assistant to upload them. Each file becomes a row of its kind, stored as it is:

• Data: YAML (.yaml), CSV (.csv) and HDF5 (.h5). Save NumPy arrays in an HDF5 file (h5py) before uploading them.
• Pictures: PNG and SVG.
• Video: mp4.
• 3D: GLB/glTF and IFC.
• Molecules: PDB, SDF, MOL, XYZ, MOL2 and CIF files, and the Protein Data Bank.

Sharing

Use the Share icon at the top of the left rail: turn sharing on and copy the link. Whoever opens it signs in (or signs up) and the presentation joins their list, read-only. Turning sharing off, or generating a new link, removes everyone's access. A viewer can import a shared presentation into their own account as an independent copy.

Plans, account and data

See Pricing for plan limits. Cloud compute hours (Pro) are spent only by cells that run on Cloud-CPU or Cloud-GPU: 1 hour = 1 CPU core for 1 hour, and 1 hour of the GPU = 15.4 hours. The time counted is the time the machine is on for your run: starting up, running, and the time it stays ready after the last run (1 minute). A cloud cell can run for 10 minutes. Browser runs are free, and so is driving Plixlab from your assistant.

To delete your account and all of its data, open Account → Manage account → Security → Delete account. Read the Privacy Policy and Terms, or browse the FAQ.

Questions or problems: contact@plixlab.com.