---
title: "How to Use MDflow in Claude Artifacts (Live MCP Data)"
description: "Use MDflow in Claude Artifacts: connect the MCP connector, ask for a page, and Claude builds a live artifact that pulls your notes on every view."
author: "MDflow"
date: 2026-07-17
reading_time: "13 min"
canonical_url: https://mdflow.cz/blog/mdflow-in-claude-artifacts
md_url: https://mdflow.cz/blog/mdflow-in-claude-artifacts.md
---

# How to Use MDflow in Claude Artifacts (Live MCP Data)

*Published July 17, 2026 · 13 min read*


You connect your notes to Claude, ask it to turn them into something you can look at, and it builds a genuinely nice page — a dashboard, a directory, a board. Then you notice the catch: it is frozen. The page shows what your workspace looked like the moment Claude built it. Reopen it tomorrow and it is already wrong.

As of July 2026, that changed. Claude artifacts can now call your **MCP connectors every time someone opens them** — so a page built from your MDflow workspace re-reads MDflow on each view and shows what is true right now. The image at the top of this post is exactly that: a live map of a real MDflow account, rendered as a Claude artifact, that updates itself. This post is about how to use MDflow in a Claude artifact, why the result is more useful than a static export, and where it fits.

> **TL;DR** — A Claude **artifact** is a self-contained interactive page Claude publishes to claude.ai. Since July 2026 it can call your **MCP connectors on every view**, so it shows live data instead of a snapshot. Connect [MDflow](/) to Claude as a connector, ask for a page — *"list my MDflow workspaces and their folders"* — and Claude builds a **live artifact** that pulls your workspaces, folders, and notes through MDflow's MCP server each time it loads. It runs as the viewer, never sees your credentials, and needs a paid Claude plan (Pro, Max, Team, or Enterprise). [Start free](/login) · [Connect an agent](/docs/mcp).

## What are Claude Live Artifacts?

A Claude artifact is a **single, self-contained web page that Claude builds from your session and publishes to a private URL on claude.ai** — a chart, a dashboard, an annotated diff, a board, anything easier to look at than to read as terminal text. A **live artifact** is one that does not stop at the moment it is built: it calls your connected MCP tools each time someone views it, so the page renders current data rather than a snapshot.

Anthropic's Claude developers announced the capability in July 2026 — artifacts that can "fetch information and take actions for each viewer on demand." It shipped for Claude Code artifacts and applies to artifacts built in claude.ai conversations too. It is available on the **Pro, Max, Team, and Enterprise** plans; connector calls from Claude Code require version 2.1.209 or later. On an older version, Claude still builds the page, but it renders whatever data the session gathered while building it — a snapshot, not a live view.

The mechanic that makes this safe is worth understanding before you build anything. When a published page calls a connector, the call runs as the person **viewing** the page, not the person who built it. Each viewer's own connectors are used; the page itself never sees anyone's credentials — claude.ai makes the calls on the page's behalf, after asking the viewer for permission the first time. Two people opening the same MDflow dashboard see their own workspaces, not each other's. The flip side: because a connector-backed page depends on the viewer having the connector, it **cannot be shared to a public link** — it stays private to you on Pro and Max, or shareable inside your organization on Team and Enterprise.

## Why live artifacts matter — for you and your AI

A live artifact is useful because it turns "my notes" into "a page my notes keep filling in" — cleanly, for two different audiences.

**For you, the person, it turns notes into tools without a build step.**

- **Live, not frozen.** The page re-queries MDflow on every open, so a map of your workspaces, a task board, or a reading list is always current. No re-export, no "let me regenerate that."
- **Nothing to deploy.** An artifact is one self-contained page with no backend and no hosting to manage. You describe what you want and Claude writes the HTML — you never open an editor.
- **Yours by default.** A new artifact is visible only to you until you choose to share it, and every connector call runs as you.
- **Iterate by asking.** "Add a last-updated column," "group by workspace," "sort newest first" — Claude edits the page and republishes to the same URL, and anyone with it open sees the change.

**For your AI and your team, the artifact is a live consumer of your knowledge base.**

- **It is a client of the same MCP server.** The page calls the exact tools Claude uses in chat — [`mdflow_get_context`](/docs/mcp), `mdflow_list_folders`, `mdflow_get_document` — but on a cadence you can see, and it re-runs them when the page loads.
- **Per-viewer, out of the box.** Send a teammate the link; once they have connected their own MDflow, they see their own account through the same page. One artifact, many private views — no shared credentials.
- **Actions, not just reads.** MDflow's MCP server also writes. A live artifact can offer a control — a button that files a note, moves a document, or updates a body — and each action runs through the clicker's own MDflow connection.

## A worked example: your workspaces and folders, live

The fastest way to feel this is the example that produced the image at the top of this post. With MDflow connected to Claude, ask:

```text
Create a list of my MDflow workspaces and the folders within each workspace.
Make it a live artifact that refreshes from MDflow when it loads.
```

Claude builds a page that calls `mdflow_list_workspaces` and `mdflow_list_folders` when it opens, then lays the result out as a workspace-by-workspace tree with a header line — *8 workspaces · 53 folders · a self-updating map of your MDflow account* — and a row of stat cards. Create a workspace or rename a folder in MDflow, reopen the artifact, and the map is already right. You never touched the page.

![The "Workspaces & Folders" Live Artifact in Claude, rendered from a real MDflow account: a "MDFLOW · LIVE ARTIFACT" header, stat cards reading 8 workspaces, 53 folders total, 28 top-level folders and 25 nested subfolders, a filter box, and a nested folder tree with each folder's description shown beneath its name.](/blog/mdflow-in-claude-artifacts-example.png)

*A real Live Artifact, straight from the prompt above. Claude called the MDflow connector and rendered the account as stat cards and a searchable, nested folder tree — descriptions and all — and it re-reads MDflow every time the page loads.*

A few more prompts that work well:

```text
Build a live artifact task board from my "Tasks" folder in MDflow — one card per
open item, grouped by status, refreshed each time the page loads.
```

```text
Make a live reading list from the pages in my "Websites" folder, newest first,
with a one-line summary under each. Pull it from MDflow on view.
```

Because MDflow ranks folder **descriptions** first, you do not have to name folders by hand. A prompt like *"show me everything about the mobile app"* lets Claude call [`mdflow_get_context`](/docs/mcp) and render a focused briefing page — the most relevant documents, not a dump of your whole account. When you plan to share the page, ask Claude to add a fallback line to each live section naming the connector it needs, so a teammate who has not connected MDflow sees what to connect instead of an empty panel.

## Which MDflow views make the best live artifacts

Live artifacts are general, but a few MDflow shapes gain the most from being self-updating rather than pasted once.

1. **Account and workspace maps.** The example above — a live org chart of your knowledge, so you can see the shape of your account without opening the app.
2. **Task and project boards.** MDflow's [markdown tasks](/markdown-tasks) as a kanban that reflects the documents themselves, not a copy that drifts the moment you check something off.
3. **Reading lists and clip inboxes.** Pages saved with the [Web Clipper](/clipper), rendered as a browsable, self-refreshing list you can hand to a teammate.
4. **Changelogs and decision logs.** A running feed of one folder that updates as you — or an agent — append to it, so the page is the log, not a screenshot of it.
5. **Team directories and runbooks.** A shared page each teammate opens against their own MDflow, so on-call sees the current runbook, not last week's.
6. **"Today's context" dashboards.** A single page that pulls the handful of documents you actually need this morning and re-reads them each time you open your browser.

The common thread: anywhere you would otherwise paste an export that goes stale in a day, a live artifact reads the source instead.

## How MDflow fits

MDflow is built to be both where your markdown lives *and* the surface your AI reaches — so a live artifact is just another consumer of the same MCP server, with nothing new to wire up.

### What already lines up today

**A remote MCP server you connect once.** MDflow runs a hosted server at [`https://mdflow.cz/api/mcp`](/docs/mcp). Add it to Claude as a custom connector over OAuth — a browser sign-in, no token to paste (the OAuth path is in beta and needs an [MDflow Pro](/pricing) account) — and MDflow becomes one of your claude.ai connectors that an artifact is allowed to call.

**Read tools an artifact renders from.** The page can list and open your whole hierarchy: `mdflow_list_workspaces`, `mdflow_list_folders`, `mdflow_list_documents`, and `mdflow_get_document`. Each folder and document comes back with its full path and a compounded description — the labeled chain of context from the top of your workspace down to the item — so the artifact has structure to lay out, not a flat list.

**Retrieval, not just listing.** [`mdflow_get_context`](/docs/mcp) is the tool that makes a *briefing* page possible instead of a directory. Give it a topic and it scores folder descriptions first, then names and titles, then returns the most relevant document bodies — so a live artifact can show "everything about X" without you naming a single file.

**Write tools for viewer-run actions.** The server is not read-only. `mdflow_create_document`, `mdflow_update_document_body`, `mdflow_move_document`, and the sharing tools let a live artifact offer controls that change your workspace — each running as the person who clicks, through their own connection.

**Markdown-native, so the page shows the real thing.** Every MDflow document is plain-text Markdown, not a proprietary format with an approximate export. What the artifact renders is exactly what you would read in the editor — and exactly what any other agent reads.

**Per-viewer safety that matches MDflow's model.** The artifact's "runs as the viewer" rule and MDflow's server-side ownership checks reinforce each other: the page never sees your token (it lives in the connector, never in a prompt), claude.ai makes every call on the page's behalf, and MDflow refuses to return anyone else's workspace. Revoke the connection from [Settings](/settings) and the page's live sections simply go quiet.

**Raw `.md` twins for the surfaces that are not MCP.** Every shared MDflow document also has a plain-Markdown twin — append `.md` to its share URL — served with YAML frontmatter and open CORS, so tools that can only fetch a URL can still read and cite it. Discovery is published too: an [`llms.txt`](/llms.txt) index, an A2A agent card, an OpenAPI 3.1 spec, and the same operations as a plain [HTTP API](/docs/api).

### Where we are headed

This is **direction, not a dated commitment**, but it is the shape of our thinking:

- **Scoped, read-only tokens.** Read-only and folder-scoped Personal Access Tokens, so a page you plan to share can be handed exactly the access it needs and nothing more.
- **Collection-level context.** Serving a whole [collection](/faq) to a page as one cross-linked bundle, so a single artifact can pull an entire curated set in one call instead of walking folders.
- **Ready-made artifact prompts.** A small gallery of copy-paste prompts — workspace map, task board, reading list — so you never start a live artifact from a blank page.
- **Discovery in lock-step.** Keeping `llms.txt`, the agent card, and the OpenAPI spec aligned with the MCP tools, so every new capability is callable from an artifact the moment it ships.

## The bottom line

For most of their life, artifacts were a beautiful way to *capture* work — and a frustrating way to *keep* it, because the moment they were built they started going stale. Calling MCP connectors on every view fixes exactly that: the page stops being a snapshot and becomes a window onto the source. Point that window at MDflow and your markdown workspace — your notes, tasks, folders, whole account — turns into live, shareable pages you built by asking, not by coding.

MDflow is the place that content can live for people and agents at the same time: markdown-native storage, a hosted MCP server, folder-description retrieval, write-back, and raw `.md` twins for the tools that need them. Connect it to Claude, ask for a page, and let it keep itself current.

[Start free](/login) · [Connect an AI agent](/docs/mcp) · [Read the API docs](/docs/api)

## Frequently asked questions

### What are Claude Live Artifacts?

A Claude artifact is a single, self-contained interactive web page that Claude builds from your session and publishes to a private URL on claude.ai. A live artifact is one that calls your connected MCP tools each time someone views it, so the page shows current data instead of a snapshot frozen when it was built. Anthropic's Claude developers announced the capability in July 2026; it is available on the Pro, Max, Team, and Enterprise plans.

### How do I use MDflow in a Claude Artifact?

Connect MDflow to Claude as a custom MCP connector (over OAuth, in beta, which needs an MDflow Pro account), then ask Claude to build a page from your workspace — for example, "Create a list of my MDflow workspaces and the folders within each workspace, as a live artifact." Claude writes an HTML page that calls MDflow's MCP tools (`mdflow_list_workspaces`, `mdflow_list_folders`, `mdflow_get_context`, and so on) when the page loads, so it re-reads MDflow on every view.

### What do I need to build a live MDflow artifact?

A paid Claude plan (Pro, Max, Team, or Enterprise), because connector-backed artifacts are gated to those plans, plus a recent Claude Code (v2.1.209 or later) or the Claude desktop/web app. On the MDflow side you need a Pro account to connect over OAuth as a custom connector. Without the connector, Claude can still build the page, but it renders whatever data the session gathered while building it — a snapshot, not live.

### Can I share an MDflow artifact publicly?

No. Any artifact that calls MCP connectors cannot be shared to a public link on any plan, because a public visitor has no connector for the page to run as. On Pro and Max it stays private to you; on Team and Enterprise you can keep it private or share it inside your organization, where each teammate views it through their own MDflow connection and sees their own account.

### Is my MDflow data safe inside a Claude Artifact?

Yes. The page never sees your credentials — claude.ai makes each connector call on the page's behalf, running as the viewer, and asks the viewer for permission the first time. Your MDflow token lives in the connector configuration, never in the page or a prompt, and MDflow enforces ownership server-side, so a viewer only ever sees their own workspaces. The connection is revocable from MDflow Settings at any time.

## Further reading

- Anthropic — [Share session output as artifacts (Claude Code docs)](https://code.claude.com/docs/en/artifacts)
- Anthropic — [Claude developers announce MCP connectors in artifacts](https://x.com/ClaudeDevs/status/2077489907350856038)
- Model Context Protocol — [Official specification and docs](https://modelcontextprotocol.io)
- MDflow — [Connect an AI agent (MCP)](/docs/mcp) · [API documentation](/docs/api) · [Markdown for AI agents](/markdown-ai) · [FAQ](/faq)