# io.github.AnkitaShanbhag30/lorem (npm · lorem-mcp)

Slide decks over MCP: read and write decks as code, run Lorem's full AI pipeline, export PPTX/PDF.

- Trust score: 59/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-07

## Components

- npm · `lorem-mcp`: 59/100 (this document), [markdown](https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp.md), [page](https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp)

## Channel facts

- Registry: `npm`
- Package: `lorem-mcp`
- Version: `0.2.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-07.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 30 of 95 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (SEE LICENSE IN LICENSE.md) isn't a recognized OSI-approved license.
  - Actively maintained (last published 0 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 75/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 3579 tokens (~102/item across 35 items; 35 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 85/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 54% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add ankitashanbhag30-lorem -- npx -y lorem-mcp
```

### Codex

```bash
codex mcp add ankitashanbhag30-lorem -- npx -y lorem-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ankitashanbhag30-lorem": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "lorem-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ankitashanbhag30-lorem --command npx --arg -y --arg lorem-mcp
```

### Hermes

```yaml
mcp_servers:
  ankitashanbhag30-lorem:
    command: "npx"
    args: ["-y", "lorem-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "ankitashanbhag30-lorem": {
      "command": "npx",
      "args": [
        "-y",
        "lorem-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-07 (score 59)

First indexed and scored.

## MCP tools (35)

### `list_decks` (~31 tokens)

List decks

List every deck with its id, title and slide count. Start here to find a deck to work on.

### `read_outline` (~61 tokens)

Read a deck outline

A compact index of a deck: one line per slide with its id, layout and title. Far cheaper than reading the whole deck — use this first, then read only the slides you need.

Input parameters:

- `deckId` (string, required): Deck id from list_decks

### `read_slide` (~54 tokens)

Read one slide

The full source of a single slide in Lore, the Lorem deck language, ready to edit and pass back to replace_slide.

Input parameters:

- `deckId` (string, required)
- `slideId` (string, required): Slide id from read_outline

### `read_deck` (~51 tokens)

Read a whole deck

The entire deck as source, including its theme frontmatter. Expensive for large decks — prefer read_outline plus read_slide unless you need to restyle everything at once.

Input parameters:

- `deckId` (string, required)

### `add_slides` (~101 tokens)

Add slides

Append or insert slides written in Lore. Prefer archetype blocks (`== hero`, `== statRow`) — they produce designed layouts. Call list_layouts to see them, or language_reference for the full syntax.

Input parameters:

- `atIndex` (integer): 0-based insert position; appends when omitted
- `deckId` (string, required)
- `dsl` (string, required): One or more `== <archetype>` blocks, no frontmatter

### `replace_slide` (~69 tokens)

Replace one slide

Rewrite a single slide, keeping its id so comments and collaborators' selections survive. Other slides are untouched, so this is safe while someone else is editing them.

Input parameters:

- `deckId` (string, required)
- `dsl` (string, required): One block replacing this slide
- `slideId` (string, required)

### `choreograph_slide` (~112 tokens)

Choreograph a slide's motion

Re-time one slide's element entrances as a coordinated sequence: cascade (role-ordered stagger), focus-pull (media lands first), rise-ensemble (everything rises together), or typewriter-lead (the title types itself out first). Timing follows the deck stylekit's motion personality; loop and exit clips the slide already carries are preserved.

Input parameters:

- `deckId` (string, required)
- `pattern` (string, required): Choreography pattern to apply
- `slideId` (string, required): Slide id from read_outline

### `delete_slide` (~30 tokens)

Delete a slide

Remove a slide by id.

Input parameters:

- `deckId` (string, required)
- `slideId` (string, required)

### `apply_deck` (~65 tokens)

Apply a whole deck document

Replace the deck with a full document (frontmatter plus blocks). Only slides that actually changed are rewritten, so untouched slides keep their ids. Use for restyling or reordering everything at once.

Input parameters:

- `deckId` (string, required)
- `dsl` (string, required)

### `reroll_deck` (~227 tokens)

Re-roll a deck's design

Redraw a deck's design without touching a word of its copy or regenerating a single image. Every slide is rebuilt from its own content with a new Style and/or a new seed: different composition, motion, crop, framing, type and colour. The text, the images, the speaker notes and each slide's layout ARCHETYPE are pinned, so this costs nothing to run and can be repeated freely — it is the tool to reach for when the words are right and the look is not. Distinct from applying a Style through apply_deck, which patches attributes in place and keeps the composition; a re-roll throws the composition away and draws a new one, discarding hand-positioned layout. Omit styleId to keep the current Style and just redraw; pass a seed to make the draw reproducible.

Input parameters:

- `deckId` (string, required)
- `seed` (string): Reproducible draw; the same seed gives the same design.
- `styleId` (string): A Style id from list_styles. Omit to redraw with the deck's current Style.

### `create_deck` (~73 tokens)

Create a deck

Make a new deck, optionally from a template (list_templates) and optionally with its slides written in Lore.

Input parameters:

- `dsl` (string): Slides to start with, as `==` blocks
- `templateId` (string): Template id, e.g. tpl_ember
- `title` (string)

### `list_layouts` (~50 tokens)

List slide layouts

Every designed layout (archetype) with the content slots it takes. Choosing a layout and filling its slots is how you get a professional-looking slide — never place elements by hand unless no layout fits.

### `list_templates` (~95 tokens)

List deck templates (deprecated — a template is a skeleton × Style)

DEPRECATED — each of these 15 flat seed ids is nothing more than one content skeleton crossed with one Style, under a fixed name. Prefer list_skeletons + list_styles + create_deck_from_style, which reaches all 19 curated Styles (not just the 15 pre-paired ones) and generates real imagery. The ids keep working forever via create_deck's templateId; the listing names the pair behind each.

### `list_personalities` (~44 tokens)

List Deck Personalities (deprecated alias for list_styles)

DEPRECATED — use list_styles, which lists the same curated Styles plus the user's own. Kept so existing callers keep working. Lists the 19 curated Styles only.

### `list_skeletons` (~45 tokens)

List content skeletons

Slide sequences a Style can be crossed with — what the deck contains, independent of how it looks. Pass one of these plus a styleId to create_deck_from_style.

### `create_deck_from_style` (~171 tokens)

Create a deck from a Style

Build a new deck by crossing a content skeleton (list_skeletons) with a Style (list_styles) — the deck's whole look: palette, fonts, spacing, shape language, decor, atmosphere, motion and transitions. A Style is a Style whether it was curated, generated from a described vibe, or imported from a .pptx / design system / website brand; styleId takes any of them. Generates real imagery matching the Style's art direction by default.

Input parameters:

- `generateImages` (boolean): Default true
- `skeletonId` (string, required): Skeleton id from list_skeletons, e.g. pitch
- `styleId` (string, required): Style id from list_styles — a curated id like `riso-pop` or a saved-style uuid
- `title` (string)

### `create_deck_from_vibe` (~113 tokens)

Create a deck from a Style (deprecated alias)

DEPRECATED — use create_deck_from_style. Identical behavior; `personalityId` is accepted as an old spelling of `styleId`. Kept so existing callers keep working.

Input parameters:

- `generateImages` (boolean): Default true
- `personalityId` (string): Deprecated spelling of styleId
- `skeletonId` (string, required): Skeleton id from list_skeletons, e.g. pitch
- `styleId` (string): Style id from list_styles
- `title` (string)

### `import_deck` (~150 tokens)

Import a deck file

Import a .pptx file (PowerPoint, or the PPTX export of Google Slides / Canva / Keynote) as a fully editable Lorem deck — every text run, color, image, table, chart and note mapped onto the native document model. Also extracts the file's visual style as a reusable Style (see list_styles), first-class next to the curated ones. Anything the model can't express is listed in the fidelity report. After importing, iterate with read_deck / replace_slide / apply_deck as with any deck.

Input parameters:

- `name` (string): Deck title override (defaults to the file's)
- `path` (string, required): Absolute path to the .pptx file on this machine

### `import_design_system` (~112 tokens)

Import a design system

Import design tokens (W3C design-tokens JSON, Tokens Studio JSON, or CSS custom properties) — or any .pptx to mine its style — into a reusable Style: palette, fonts, type scale and radii become a Style that drives deck generation and restyling exactly like the curated ones.

Input parameters:

- `name` (string): Name for the imported style
- `path` (string, required): Absolute path to the tokens .json / .css file (or a .pptx to style-mine)

### `import_brand_from_url` (~120 tokens)

Extract a brand from a website

Fetch a public website, classify its CSS colors and fonts into a Lorem palette, and save the result as a reusable Style — the fastest way to make decks match a company's brand. Returns the styleId plus the extracted palette/fonts; use it with create_deck_from_style({skeletonId, styleId}) or apply the palette to an existing deck via apply_deck.

Input parameters:

- `name` (string): Name for the saved style (defaults to '<host> brand')
- `url` (string, required): Public website URL, e.g. stripe.com

### `create_style` (~360 tokens)

Invent a Style

Invent a NEW Style from a description — the catalog is not a fixed list of 19. Describe the look in words ("a cozy library", "1970s NASA telemetry", "a risograph zine") and get back a complete Style: palette, font pairing, shape language, decor, atmosphere, motion character, slide transitions, AND the policy axes that lean which composition, entrance and pose each slide draws — so an invented Style behaves differently, not just looks different. Say who the deck is for (persona) and what job it is doing (useCase) and both the look and those leanings follow the brief: a reference card comes back still and left-aligned, a portfolio comes back reaching. Every invented Style is verified before it is returned — palette contrast, body-font legibility, type-scale floors, plus a real probe build measured for contrast failures, collisions, off-slide elements and overflow — and one that fails is reported, never handed back. Saves by default and returns a styleId usable with create_deck_from_style, apply_deck or reroll_deck.

Input parameters:

- `description` (string, required): The look, in words — e.g. "sun-bleached surf shop, hand-painted signage"
- `name` (string): Name for the saved Style (defaults to the invented one)
- `persona` (string): Who is speaking to whom
- `register` (string): The deck's voice, one short phrase
- `save` (boolean): Save it to the Styles list (default true). false previews without keeping it.
- `topic` (string): The deck's subject matter, for context only
- `useCase` (string): The job this deck is doing — decides how far the Style may reach

### `list_styles` (~102 tokens)

List Styles

Every Style available to this user, grouped by where it came from: 19 curated Styles, plus any generated from a described vibe or imported from a .pptx, design system or website brand. A Style is a complete look — palette, fonts, spacing, shape language, decor, ambient atmosphere, motion character, slide transitions — that cascades from one pick. Cross one with a skeleton from list_skeletons and pass both to create_deck_from_style.

### `language_reference` (~42 tokens)

Deck language reference

The full syntax of Lore, the Lorem deck language, generated from the layout schemas so it is never out of date. Read this once before writing anything non-trivial.

### `validate` (~44 tokens)

Check Lore without applying it

Parse a document or fragment and report errors and warnings. Nothing is changed.

Input parameters:

- `deckId` (string): Validate against this deck's theme
- `dsl` (string, required)

### `generate_image` (~63 tokens)

Generate an image

Create an image from a text prompt and return its asset id, for use as `image: asset:<id>` in a slot or `image asset:<id>` as an element. Requires the server to have an image model key configured.

Input parameters:

- `prompt` (string, required)

### `list_fonts` (~119 tokens)

Browse the font catalog

Search the ~140-family font catalog by mood, theme or name — e.g. "horror", "kids playful", "elegant serif", "pixel arcade", "western". Every family is Google-hosted and loads automatically when referenced by name in a deck theme (`fonts:` frontmatter) or on a text run (`font="…"`). Use it to pick type that matches the content instead of defaulting to a generic sans.

Input parameters:

- `query` (string): Mood/theme/name keywords; omit to list the whole catalog grouped by category

### `generate_deck_images` (~123 tokens)

Generate all declared images in a deck

Fill in every AI-declared image in a deck at once. In the deck language, `image gen {prompt="misty harbor at dawn" x=… y=… w=… h=…}` places an image that renders as a placeholder until generated; this tool generates each one (honoring the theme's imageStyle) and wires the assets in. Run it after create_deck/apply_deck when the document declared `image gen` elements. Requires the server to have an image model key configured.

Input parameters:

- `deckId` (string, required)

### `generate_outline` (~150 tokens)

Plan a deck outline with the AI pipeline

Stage 1 of the same generation pipeline the app's wizard uses: an art-direction pass plans the argument and look, then a writer produces one validated outline slide per archetype. Returns the outline slides and the design brief as JSON — pass both to generate_deck unchanged to build the deck. Prefer this over hand-writing an outline when the user gives a topic rather than finished content.

Input parameters:

- `direction` (string): Free-form creative direction
- `prompt` (string, required): What the deck is about — topic, audience, goal
- `slideCount` (integer)
- `sourceText` (string): Source material to outline from
- `styleId` (string)
- `tone` (string)

### `generate_deck` (~205 tokens)

Build a deck end-to-end with the AI pipeline

Stage 2 of the app's generation pipeline: assembles an approved outline into a saved deck — designed layouts, copy, AI/stock imagery, then the quality loop (a vision judge scores the rendered deck and the worst slides get a polish pass) before saving. This is the full in-app experience over MCP: use generate_outline first, then this. Returns the new deckId plus the quality report (initial → final score, revised slides). Style precedence: styleId > personalityId > templateId.

Input parameters:

- `brief` (object): The design brief from generate_outline, echoed back unchanged
- `generateImages` (boolean)
- `imageStyle` (string)
- `outline` (array, required): Outline slides from generate_outline, unchanged
- `personalityId` (string)
- `prompt` (string): The user's original ask, for the generation record
- `styleId` (string)
- `templateId` (string)
- `title` (string)

### `edit_deck` (~189 tokens)

Edit a deck with the in-app AI edit loop

Run the same agentic "Edit with AI" loop the editor's panel uses: it reads the deck, can look at rendered slides (a vision pass), generate or edit images, add archetype slides, and emits operations — which this tool then applies through the live collaboration room, so open browsers update instantly and the whole edit is one undo. Use it for design-quality passes ("review every slide and fix what looks off"), content rewrites, or anything you'd type into the app's AI panel. Prefer replace_slide/apply_deck when you already know the exact change.

Input parameters:

- `deckId` (string, required)
- `focusSlideIds` (array): Pin these slides as context
- `focusTheme` (boolean): Pin the theme as context
- `instruction` (string, required)
- `slideId` (string): The slide the edit is 'on' (defaults to the first slide)

### `set_deck_music` (~137 tokens)

Set or clear the deck soundtrack

Give a deck an AI-generated soundtrack that plays during Present mode. Generates audio from a musical brief — mode "instrumental" for pure music, "lyrical" to steer toward sung vocals about `lyrics` — then attaches it to the deck as one undoable operation (also expressible in the deck language as `music:` frontmatter). Generation runs roughly in real time, so expect ~30s. Pass remove:true to clear the soundtrack instead.

Input parameters:

- `deckId` (string, required)
- `lyrics` (string)
- `mode` (string)
- `prompt` (string)
- `remove` (boolean)

### `save_as_template` (~52 tokens)

Save a deck as a template

Promote a deck to the template gallery, so new decks can start from its design and structure. Use once a deck is worth reusing.

Input parameters:

- `deckId` (string, required)
- `name` (string, required)

### `delete_deck` (~28 tokens)

Delete a deck

Permanently remove a deck. There is no undo.

Input parameters:

- `deckId` (string, required)

### `export_deck` (~55 tokens)

Export a deck

Get a download URL for the deck as native PowerPoint or PDF. PowerPoint exports as real editable shapes, text and charts — not pictures of slides.

Input parameters:

- `deckId` (string, required)
- `format` (string)

### `get_generation_insights` (~136 tokens)

Generation insights

How past AI generations were received: win-rates per style, archetype and choreography pattern, feedback-tag frequencies and trend, and the human and AI quality passes reported side by side (never averaged — they measure different things). Use this to decide what to change about generation, and to see which recurring complaints might deserve a curated prompt adjustment.

Input parameters:

- `limit` (integer): Generations to scan, newest first (default 50)
- `since` (string): ISO datetime lower bound, e.g. 2026-07-01T00:00:00Z
- `until` (string): ISO datetime upper bound

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp#diagnostics

## Score history

- 2026-08-07: 59

## Links

- npm package: https://www.npmjs.com/package/lorem-mcp
- Socket report: https://socket.dev/npm/package/lorem-mcp
- Website: https://lorem.fly.dev/
- Changelog RSS feed: https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp.json
- HTML version of this page: https://verifymcp.io/servers/ankitashanbhag30-lorem/lorem-mcp