Inplain

Servidor MCP y CLI que convierten una frase en una presentación, un documento o un panel de control terminados: entrada en texto sin formato y salida como página web independiente. Funciona con tu propia clave de API o completamente en local con Ollama.

Documentación

Plain

Presentations, reports, and dashboards your AI agent can actually make.

Plain turns one sentence into a finished artifact — a deck, a long-form doc, or a data dashboard — rendered as a self-contained web page. It ships as a CLI and an MCP server, so Claude Code, Cursor, or any MCP-aware agent can produce one mid-task and hand back the result.

npm install -g @inplain/cli
export ANTHROPIC_API_KEY=sk-...        # or OPENAI_API_KEY, or OLLAMA_BASE_URL
plain install                          # wires it into Claude Code / Cursor / VS Code

Then, from inside your agent:

"Read src/payments and build me an 8-page deck on what shipped this sprint."

See what comes out: deck · doc · sheet — each is the literal output of one plain generate call, published without hand-tuning.

Why an agent needs this

Agents are good at deciding what a document should say. They're bad at producing the document — most tooling makes them emit a .pptx blob they can't inspect, or raw HTML they can't reliably edit later.

Plain's artifacts are plain text in, web page out:

  • Source is text — Markdown, CSV, a small DSL. An LLM can edit it precisely with a JSON Patch instead of regenerating the whole thing.
  • Output is a self-contained page — one HTML file, no build step, no runtime.
  • Office formats are an export, not the product. .pptx / .docx / .xlsx exist for people who need them.

One model, three expressions:

FormIsSource
deckA presentation — scroll or present modeMarkdown
docA long-form report with charts and diagramsMarkdown + frontmatter
sheetA data dashboard (KPIs, charts, tables)CSV + prose + chart spec

Use it

As an MCP server — what most people want:

plain install          # writes config for Claude Code / Cursor / VS Code
plain mcp              # or run it in the foreground to debug

Manual MCP config — the same entry plain install writes. Add it to ~/.cursor/mcp.json or ~/.claude.json:

{
  "mcpServers": {
    "plain": {
      "command": "plain",
      "args": ["mcp"]
    }
  }
}

Tools: generate_artifact, edit_artifact, export, plus per-form variants and Office exporters (see the caveat below). generate_artifact publishes the result and returns a shareable URL alongside the source.

As a CLI — scriptable, pipes cleanly:

plain generate "Q3 board update" --as deck -o out.html
plain deck edit out.md --patch '[{"op":"replace","path":"/slides/0/title","value":"Q3"}]'
plain export out.md --to html

Office export (--to pptx|docx|xlsx) currently only handles the older Marp-style source (marp: true frontmatter), not the v2 format generate produces. Web-native HTML is the supported path for everything.

As a library — the rendering pipeline is a plain dependency:

import { marpToDeck, deckDocToPptx, findRefs } from "@inplain/core";

Model backends

Any one of these works:

ProviderEnv var
AnthropicANTHROPIC_API_KEY
OpenAIOPENAI_API_KEY
GoogleGOOGLE_GENERATIVE_AI_API_KEY
MoonshotMOONSHOT_API_KEY
DeepSeekDEEPSEEK_API_KEY
Ollama (local)OLLAMA_BASE_URL=http://localhost:11434

With Ollama, nothing leaves your machine. Each agent role (router, generator, editor) can point at a different model via ROUTER_PROVIDER / GENERATOR_MODEL and friends.

What's in here

packages/core/    Rendering pipeline, document model, serializers, Office export
packages/cli/     @inplain/cli — the CLI, the MCP server, and the agent skill
scripts/          Smoke tests (no LLM calls, no network)

packages/core is where an artifact becomes a web page: the V32 document model, 37 templates, the theme engine, and the deck/doc/sheet renderers. It's pure functions — no IO, no network, no framework.

Develop

pnpm install
pnpm plain --help          # run the CLI from source
pnpm build                 # bundle it

Four checks, all must pass:

pnpm typecheck
pnpm core:smoke            # 4 checks — parse, patch, render, export
pnpm build
pnpm cli:smoke             # 11 checks — including a live MCP server over JSON-RPC

Neither smoke suite calls an LLM or touches the network, so they run anywhere.

Already have an HTML file?

If you're not generating anything — you already have a finished .html and just want a link to send someone — that's a different (and much shorter) path: drop it at inplain.app/html-to-url and you get an https URL. No account, no build step.

中文说明:把本地 HTML 文件转成链接

From the CLI, same thing in one command:

plain publish ./report.html          # → https://inplain.app/s/...
plain publish ./decks/*.html         # batch
plain --json publish ./*.html | jq -r .url

Agents can do it too — the MCP server exposes publish_html for files that already exist on disk (as opposed to generate_artifact, which writes new ones).

Without credentials links expire in 7 days; plain login makes them permanent.

Hosted version

inplain.app runs a hosted workspace on top of this — a web editor, shared links, and a managed model gateway. Everything in this repository works fully against your own API keys; the hosted service is optional.

License

MIT