Build decks with an AI assistant

Use a compatible external MCP client to read and edit Quodra documents. Hosted access needs account configuration; local setup currently needs authorized access to the private source repository.

Quodra speaks MCP (the Model Context Protocol), the standard way an AI assistant talks to an application. Connect one and it can read your decks, create new ones, and edit them using the same vocabulary the editor uses. It is not pasting text into a template: it places objects, sets parameter ranges, and wires a slider to the thing it drives.

You bring the AI client and model provider. Quodra exposes document tools through MCP; it does not provide built-in model inference. Content your client reads is available to that client and is processed under the terms of the provider you choose. Hosted MCP runs on Cloudflare and connects to Quodra's Google Cloud API.

Two things stay true whatever the assistant does:

• Changes are validated against the document schema before they are written. Schema validation checks structure; review generated content and scientific claims yourself.
• A batch lands whole or not at all. If the fourth of six edits is wrong, none of the six are written, and you are told which one failed and why.

Choose how to connect#

There are two ways in, and the difference is where your decks live.

The local server does not require a Quodra account to write files, but it is not a public self-service installation: its source repository is private and no public npm package is available. Opening those files in a saved cloud workspace still requires beta access. Hosted writes to the cloud workspace your account can access.

If you are evaluating Quodra without source or account access, start with the public sample. For MCP availability, contact the team; a request does not guarantee source or hosted access.

Connect: local#

Proceed only if you already have authorized access to a Quodra source checkout. An anonymous GitHub 404 is consistent with a private repository; these instructions do not provide repository access. The package is marked private and builds for Node.js 20 or later.

From the root of your authorized checkout:

npm install
npm run build -w packages/mcp

Then add it to your MCP client's configuration. For Claude Desktop that is claude_desktop_config.json; for other clients, the file their documentation names.

{
  "mcpServers": {
    "quodra": {
      "command": "node",
      "args": ["/path/to/Quodra/packages/mcp/dist/quodra-mcp.mjs"]
    }
  }
}

Restart the client. Decks are written to ~/Quodra by default. To put them somewhere else, pass --workspace or set QUODRA_WORKSPACE:

{
  "mcpServers": {
    "quodra": {
      "command": "node",
      "args": [
        "/path/to/Quodra/packages/mcp/dist/quodra-mcp.mjs",
        "--workspace", "/Users/you/Documents/decks"
      ]
    }
  }
}

To open what it built: Dashboard → Import a file, or File → Import JSON… in the editor. The file is a .quodra.json, which is a normal file — keep it in git, send it to a colleague, diff two versions of it.

Connect: hosted#

Hosted MCP is a URL rather than a command, and it authenticates as you.

Open Settings → Model Context Protocol in Quodra. Where your sign-in configuration supports it, Copy connection details provides the endpoint and token in the shape a client expects:

{
  "mcpServers": {
    "quodra": {
      "type": "http",
      "url": "https://mcp.quodra.app",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

The assistant reaches exactly the decks you can reach, and every write is recorded as a revision you can inspect and roll back.

What to ask for#

The assistant discovers Quodra's vocabulary on its own, so you can ask in your own words. What helps is being concrete about the model rather than the slides:

> Build me a five-slide deck on RC transients. Start with the schematic, then

> the exponential, then a slider for the resistance wired to the resistor so the

> time constant moves when I drag it.

> Open "Lecture 4" and add a slide after the divider showing the same circuit at

> 5 V instead of 9 V.

> In my thesis defence deck, find where I defined the diffusivity and tell me

> which slides read it.

Asking for a parameter wired to something is the request worth making. A deck of sliders that move nothing is the thing an assistant will otherwise happily build, and Quodra gives it the tools to do better.

What it can do#

Read — list your decks, read a deck's outline, read one slide in full, and search every deck for a formula, a variable, or a phrase.

Author — create decks, add and reorder slides, place supported object types — text and figures through circuits, molecules, and the whole Matter Lab family (crystals, phase diagrams, XRD, spectra, stress–strain, micrographs, Gibbs curves, Ashby charts, trajectories, fields) — write speaker notes, and set which Python packages a deck loads. A valid object in a file does not establish account access to its studio, Python execution or export fidelity.

Wire — add parameters and their variables, set ranges and units, and bind a variable to a number on another object: a resistor on a schematic, a pendulum's length, a phase diagram's temperature, a trajectory's frame. It can also author choices — named option sets like phase: ferrite / austenite — and bind them to choice slots such as a crystal's representation. And it can see what a read-out currently works out to, so it can tell whether the formula it just wrote resolves.

Move decks in and out — export a deck as PowerPoint, or bring a .pptx in and get a report of what came across cleanly. Export and re-import the raw document. Delete a deck.

Check — validate a deck against the schema, and ask what you are allowed to do with one before starting a long edit.

With hosted, also — read revision history, read any past revision and restore it, see who has been doing what to a deck, read and write comment threads, upload images, list your workspaces and who is in them, create a share link, and invite or remove collaborators.

Requests that change who has access#

Some MCP tools change access or contact other people. Be explicit when asking your client to perform these actions, and review the client's approval controls:

• Creating a share link publishes the deck to anyone holding the address.
• Inviting a collaborator sends mail to a real person and gives them access.
• Removing a collaborator takes their access away, and they are not told.

What it cannot do#

• Run your Python. MCP authors source code. Execution happens in the editor under Pyodide, subject to feature access, trust and run settings. Review generated code and run it to check its results.
• Export a PDF or images. Those are drawn by your browser, so they stay in the app. PowerPoint export works because that format needs no renderer — but it lacks the browser captures used for scientific objects. Supported text, shapes, tables and data-bound charts can remain native; other content uses text or placeholders. Review the conversion report and exported file.
• Reach the Circuit or Molecule Studio libraries. Those are separate documents living in their own place. A circuit or molecule on a slide is a different matter and is fully editable — an assistant can add a resistor, change a supply voltage, or swap a molecule's structure, and then wire a slider to the component it just added.
• Present, or touch a deck you have open in front of you. MCP writes to the file or your cloud workspace; the editor picks the change up when it loads.
• Reach anything you cannot. Hosted MCP is bounded by your own permissions.

If something goes wrong#

"That is not a document Quodra can open." The assistant tried to import something malformed. Nothing was written — ask it to try again.

An edit was refused and nothing changed. That is the atomic guarantee doing its job. The error names the intent that failed and why; give that to the assistant and it can usually correct itself.

The deck is not on my dashboard. Local MCP writes files, not cloud decks — import the file. Check the folder with the assistant's workspace status tool if you are not sure where it landed.

A slider does nothing. It was placed but never wired. Ask the assistant to wire it, naming what it should drive.

Next#

• Reactive documents — what a parameter is and what it can drive.
• Import & export — the .quodra.json format by hand.
• Account & privacy — tokens, access, and what is stored.