Skip to main content
Glama
Sign In
deenesjakoruzh
Slideforge

Slideforge

by smartdatabrokers
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Remote

mcp-name: dev.slideforge/slideforge

SlideForge MCP — PowerPoint slides for AI agents

SlideForge (slideforge.dev) — the deterministic PowerPoint compiler for AI agents. Typed slide intents → native, fully editable .pptx in under a second, with a fidelity manifest that states exactly what was bound verbatim. Built by Smart Data Brokers GmbH, Switzerland.

Remote MCP server + REST API. No local install, no Python environment, no python-pptx boilerplate. OAuth 2.1 for Claude Desktop & ChatGPT; API key for everything else.

License: MIT Website Docs

⚠️ Disambiguation

"SlideForge" is used by multiple unrelated projects. This is SlideForge by Smart Data Brokers GmbH at slideforge.dev. Not affiliated with:

  • slideforge.io — a separate AI presentation generator

  • slideforge.fr — a French document polishing service

  • blink.new/p/slideforge-app — an unrelated web app

  • Other github.com/*/SlideForge repositories outside the smartdatabrokers org

When citing or linking, prefer slideforge.dev or "SlideForge by Smart Data Brokers."

Related MCP server: PowerPoint MCP Server

Why SlideForge

  • A compiler, not a generator. A slide is a typed intent: pick a form from 200+ catalog patterns (KPI dashboards, waterfalls, Gantt plans, org charts, funnels, …), put your real content in typed fields. A deterministic engine lays it out — no LLM in the render path, same input → same slide, sub-second.

  • The honesty layer. Every response carries a fidelity manifest: per field, was your content bound verbatim, mixed, or ai_completed? A partial grade means some supplied content didn't make it onto the slide — the manifest names what was dropped; never deliver a partial render without telling the user what's missing. Slides with blocking defects don't bill (usable-or-free). If your agent feeds numbers into slides, this is what makes the output auditable.

  • Native, editable .pptx. Real shapes and text boxes — not images, not HTML exports. Openable and editable in PowerPoint.

  • Escape hatch included — under the same trust contract. mode=code runs your own python-pptx in a sandbox (widget/chart toolkit, theme injected, intent fields render as chrome). Code renders are linted, measured (layout block + presentation_ready), and provenance-checked — agents may escape the layout grammar, never the trust grammar.

  • Your template, natively. Upload your company's .pptx — slides are built ON your file (theme, masters, fonts), not a color-matched imitation.

  • Check for free. dry_run validates any payload + forecasts fidelity at $0 — or use mode=safe to validate-then-render in ONE call (renders + bills only if faithful; else a $0 report with the fix). verify tiers on code renders (lint default, lint+vlm adds a visual second-look). quality_profile (executive/technical/appendix) sets the readiness bar the layout is judged against — answered on any form. Free deck inspect (POST /v1/inspect) runs a deterministic quality report on any pptx.

  • 97% quality parity with Gamma in our own blind side-by-side benchmark (internal instrument, not third-party).

Pricing in one breath: creating a slide 5¢ · transforming a slide 2¢ (translate, repair) · checking free. 60 free slides on signup, no subscription. slideforge.dev/pricing

Quick Start

One click, no config file:

 

VS Code (Copilot agent mode) signs you in over OAuth on first use — no key, no JSON file.

Cursor installs with an API-key placeholder: after clicking, replace sf_live_YOUR_KEY in the server's headers with a real key from the console. Cursor's own OAuth browser launch is broken as of 3.16.17, so the key is the working path there today.

Claude Code

claude mcp add --transport http slideforge https://api.slideforge.dev/mcp/

Then just ask: "Make a KPI dashboard slide: revenue $12.4M (+18% YoY), 847 new clients, NPS 62."

Optional — install the skills + bundled server config as a plugin:

/plugin marketplace add smartdatabrokers/slideforge-mcp
/plugin install slideforge@slideforge-mcp

Or copy any folder from skills/ into ~/.claude/skills/ (personal) or .claude/skills/ (project).

Claude Desktop (OAuth — no key needed)

Settings → Connectors → Add custom connector → https://api.slideforge.dev/mcp/ — sign in with Google on first use.

ChatGPT (Developer Mode)

Settings → Apps → Advanced → Developer mode → Add custom connector → https://api.slideforge.dev/mcp/ (OAuth).

Cursor / Windsurf / Codex CLI / any MCP client (API key)

{
  "mcpServers": {
    "slideforge": {
      "url": "https://api.slideforge.dev/mcp/",
      "transport": "streamable-http",
      "headers": { "Authorization": "Bearer sf_live_YOUR_KEY" }
    }
  }
}

Get a key: slideforge.dev → Console → API keys. (Codex CLI and other AGENTS.md-native tools: see AGENTS.md.)

Run it locally (stdio — for container/offline clients)

Most clients should use the hosted remote server above (no install). But if your client boots MCP servers from a container or a local stdio process, run the bundled local server. It's a thin REST client over api.slideforge.dev — it holds no engine logic; the tool schemas are baked in locally (so discovery works offline, no key) and each call forwards to the SlideForge REST API authenticated with your key.

pip install slideforge-mcp        # or: uv pip install slideforge-mcp
export SLIDEFORGE_API_KEY=sf_live_YOUR_KEY
slideforge-mcp                    # speaks MCP over stdio

Or via Docker:

docker build -t slideforge-mcp .
docker run -i -e SLIDEFORGE_API_KEY=sf_live_YOUR_KEY slideforge-mcp

Client config (stdio):

{
  "mcpServers": {
    "slideforge": {
      "command": "slideforge-mcp",
      "env": { "SLIDEFORGE_API_KEY": "sf_live_YOUR_KEY" }
    }
  }
}

Schema discovery (tools/list) needs neither a key nor network; tool calls need the key.

LangChain / LlamaIndex (agent frameworks)

No SlideForge SDK needed — both load the MCP tools directly:

pip install langchain-mcp-adapters      # or: pip install llama-index-tools-mcp
from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({"slideforge": {
    "transport": "streamable_http",
    "url": "https://api.slideforge.dev/mcp/",
    "headers": {"Authorization": f"Bearer {API_KEY}"}}})
tools = await client.get_tools()        # 7 tools, drop into any LangGraph agent

Runnable examples + the LlamaIndex equivalent: examples/. Need a key? Sign up — 60 free slides, no credit card — then grab it at console/keys.

REST (no MCP)

curl -X POST https://api.slideforge.dev/v1/render/intent \
  -H "Authorization: Bearer sf_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"form": "kpi_metrics", "headline": "Q3 at a glance",
       "data": {"metrics": [{"label": "Revenue", "value": "$12.4M", "delta": "+18% YoY"},
                             {"label": "New clients", "value": "847"},
                             {"label": "NPS", "value": "62"}]}}'

Full REST reference: slideforge.dev/docs/api

The 7 MCP tools

Tool

What it does

Cost

create_slide

ONE slide from a structured intent (form + typed fields) or a brief; mode=safe validates-then-renders in one call; mode=code for sandboxed python-pptx (verify tiers, chrome fields, patch-by-replacements). Routing controls: variant, variant_policy, allow_fabrication/allow_truncation/allow_low_confidence (honest defaults: reject at $0 rather than guess). min_font_pt sets a BINDING type floor — text grows to meet it where the box allows; content that cannot fit returns a $0 min_font_not_met error naming the size it needs. Response carries the fidelity manifest + a measured layout readiness block on diagram forms. Default themes ship topical design — a subject-informed palette + designed cover, named in the response's design note (styling: "clean" opts out; your pinned/uploaded brand theme always wins).

$0.05 (usable-or-free)

create_deck

Whole deck: slides[] of intents (code-mode slides are first-class children), parallel render, one merged .pptx, per-slide fidelity rollup + per-slide child jobs (own preview/pptx). Failed slides isolated + free; deck-level dry_run validates the whole deck at $0. Deck-level language, direction (rtl for Arabic/Hebrew — typeset right-to-left, layout unmirrored + honestly warned), imagery/imagery_tag, styling and logo_id inherit into every slide; a slide's own value wins.

N × $0.05

plan_slide

Brief → top form/variant candidates with confidence.

Free

browse_catalog

200+ patterns with per-form JSON Schemas + copy-pasteable example intents, themes, the code-mode widget toolkit. Pass an uploaded theme_id to list its branded cover/agenda/divider layouts. type=brands lists your brand kits with their versions. 9 built-in themes + your uploaded brand kits.

Free

translate_deck

Translate any PPTX preserving formatting (32 languages).

$0.02/slide

upload_asset

Logos, brand template PPTX, images; purpose=pdf extracts a PDF into editable slide intents (PowerPoint/Keynote/Google-Slides/Beamer-exported PDFs only — other sources aren't supported yet); or AI-generate an image. Brand template upload (purpose=brand — purpose=theme is the same thing under its old name, still accepted) renders NATIVE by default — decks are built on the client's own template file. Omit data on large files for an in-card drag/drop zone.

Free / $0.01/page / $0.05/image

manage_account

Balance, usage, jobs, security status, feedback, action=feedback_list to read your filed reports back, action=brand_report for a brand kit's per-token fidelity report.

Free

dry_run: true on create tools = validation + fidelity forecast at $0.

Two more tools (generate_report, manage_connections — data-driven reports from connected tools like Zoho Sprints) exist behind an enterprise gate and are not served by default.

Also on REST (for now): the Deck Doctor. POST /v1/inspect — a free deterministic Deck Quality Report for any pptx (overflow via real font metrics, content hidden behind shapes, off-canvas leftovers, WCAG contrast). POST /v1/repair — deterministic fixes, never your words, $0.02/repaired slide, free dry-run quote. Docs

Brand kits

A brand kit is your org's identity — colors, type, logo, and (optionally) an uploaded .pptx/.potx/.thmx template — stored under a slug and rendered against on every call.

  • Use one: pass theme_id=<slug> to create_slide/create_deck for the kit's default version, or <slug>@<n> to pin a specific version.

  • Create one: upload_asset(purpose="brand", data=<base64 .pptx/.potx/.thmx>) — decks then render NATIVE, built on your own template file. (purpose="theme" is the same path under its old name and still works.)

  • Discover: browse_catalog(type="brands") lists your kits with their versions.

  • Check fidelity: manage_account(action="brand_report", theme_id=<slug>) returns the per-token fidelity report for a kit.

  • Export or import from a URL: full kit CRUD, DTCG tokens.json/.potx/.thmx export, and importing an identity straight from a company's domain are REST-only today — /v1/brands (not yet mirrored as MCP tools).

Security

  • Tool result bodies are credential-free — no signed URLs in responses. Previews are embedded inline (the agent looks at the PNG directly); the .pptx downloads via header-auth (Authorization: Bearer + ownership check), not a bearer-in-URL.

  • Need a shareable link instead? POST /v1/jobs/<job_id>/download-url mints a short-TTL, single-use, revocable link.

  • Artifacts auto-delete 30 days after creation.

  • Every download is audit-logged.

  • manage_account(action=security_status) discloses the full posture in-band.

Agent skills (this repo)

Copy-in skills that teach an agent to use SlideForge well — see skills/:

Skill

Teaches

create-slide

Intent-first slide/deck creation, schema discovery, dry-run, fidelity manifest, headless preview

inspect-repair

Free Deck Quality Report on any pptx + deterministic repair

translate-pptx

Format-preserving PPTX translation

pdf-to-pptx

PDF → editable PPTX extraction

For Codex CLI / Cursor / Copilot and other AGENTS.md-native tools, AGENTS.md carries the same guidance in the portable format. CLAUDE.md imports it for Claude Code.

Headless usage (Claude Code / Codex CLI)

No inline widgets in a terminal, but the tool result already embeds the preview PNG inline — the agent reads it directly out of the response, no fetch needed. The .pptx downloads via header-auth:

curl -H "Authorization: Bearer sf_live_YOUR_KEY" \
  -o deck.pptx https://api.slideforge.dev/v1/jobs/<job_id>/pptx   # ownership-checked

To hand off a shareable link instead of the raw file, mint a single-use one: POST /v1/jobs/<job_id>/download-url — short-TTL, revocable, works once.

The self-review loop (render → view inline preview → fix → re-render) is documented in examples/claude-code.md.

How it compares

SlideForge

python-pptx

Prompt-only AI decks

Editable native .pptx

✅

✅

often images/exports

Deterministic (same input → same slide)

✅

✅ (your code)

❌

States what was AI-touched (fidelity manifest)

✅

n/a

❌

Layout quality without hand-coding

✅ 200+ patterns

❌ DIY

varies

Hosted, agent-native (MCP + REST)

✅

❌ local

partial

Free pre-flight validation

✅ dry_run

n/a

❌

Links

License

MIT (this repo: skills, examples, docs). The SlideForge service itself is a commercial API.

Available Tools

7 tools
browse_catalogBrowse SlideForge's Catalog (Unified Discovery)A
Read-onlyIdempotent
Inspect

Browse the PowerPoint slide catalog progressively. No args -> form overview (when-to-use, bound fields, variant counts). family= -> variant one-liners. q= -> ranked search. variant=/prior_id= -> example payload. type=schema + family -> a compact family-level variant chooser (not a sendable contract); type=schema + family + variant -> that variant's exact payload contract (JSON Schema, capacity, field mapping, examples). Free. Code path: type=widgets = the add_widget() catalog (name= for its contract + thumbnail); type=helpers = python-pptx helper signatures. type=themes + an uploaded theme_id -> that template's branded FURNITURE layouts (its own cover/agenda/divider/closing slides + fill schemas + previews) — render via create_slide(form=template_layout, theme_id, data={layout, fills}).

Inputs: q, top, name, type, +7 more.

create_deckCreate Multi-Slide DeckAInspect

Create a complete PowerPoint presentation (.pptx): a whole multi-slide deck, native and editable, in one call. slides is a list of create_slide intents (same form menu + data shapes — see create_slide). Slides fill in parallel and merge into one themed PPTX with page numbers. Include furniture: a hero_statement cover, section_divider breaks, and a closing (hero_statement variant=contact_closing via blocks-free slots).

BLOCKED ($0)? If an error has can_autofix:true, merge its patch into the args at patch_target. Unchanged retries repeat the block. New form: browse_catalog(type=schema) first.

Also: mode=assemble merges existing slide job_ids as-rendered (free; theme_id does NOT re-theme them — render with create_deck(slides=[…], theme_id=…) for a unified theme); mode=fork clones a deck (free). Polling: deck_id == job_id — manage_account(action=job, job_id=<deck_id>).

Inputs: mode, name, title, slides, +13 more.

create_slideCreate or Inspect a SlideAInspect

Create one PowerPoint slide (.pptx, native, editable) from a structured intent in ONE call: pick a form from the menu and put your content in the typed fields (placed on the slide as given), or pass a brief and let the server route it. Fields tagged (per-form) bind only where the form has that slot — ignored-with-warning elsewhere; see each form's binds in browse_catalog.

BLOCKED ($0)? If an error has can_autofix:true, merge its patch into the args at patch_target. Unchanged retries repeat the block. New form: browse_catalog(type=schema) first.

FORM MENU: agenda_list: an ordered list of sections/topics or learning objectives to walk through bar_rank_chart: bars comparing magnitudes across categories calendar_grid: events on a real calendar - week planner (day x hour) or month grid with event chips (data.events) card_grid: several equal, unordered peer blocks (features, options, pillars, a concept's defined parts, rules/guidelines/common mistakes) case_story: one named story told as evidence: challenge, action, measured result comparison_matrix: options x criteria grid: data.columns x data.rows cycle_flow: a closed loop of ordered stages where the last feeds the first (recurring process) data_table: a plain factual table of records by fields editorial_split: two side-by-side halves: contrast (before/after, problem/solution) or copy/numbered steps beside a picture (image_src) exercise_prompt: an exercise/practice/discussion prompt: instruction + hints; optional problem items with blank answer boxes funnel: a quantity narrowing through ordered stages gantt_plan: tasks as bars across named periods on a schedule grid gauge_score: one score on a dial against a scale hero_statement: a statement slide: covers (typographic/image/exec), from->to/thesis-quote transitions, statement/contact/next-steps closings; supporting points -> takeaway_stack, contacts -> data.contacts, next steps -> data.next_steps hub_spoke: one central element with several elements connected around it image_story: a picture shown WHOLE (uncropped) + prose, or a 1-6 picture/placeholder gallery (data.images); points beside a picture -> editorial_split kpi_metrics: a metrics dashboard: headline metric cards; data.sections (Highlights/Risks/Asks) makes it an exec summary / QBR snapshot layer_stack: stacked layers where higher sits on, and depends on, lower linear_flow: ordered process stages read left to right (or inputs to process to outputs) maturity_staircase: ascending levels climbing to a higher state nested_magnitude: nested containment - each level contains the next org_structure: a reporting hierarchy / org tree position_map: items placed by two axes - named 2x2 cells or scatter positions pyramid_hierarchy: a triangle of stacked tiers, foundation to apex ramp_curve: a continuous rising wedge split into phases - effort or value accumulating over time section_divider: a section-break: big section number + title; blocks = agenda progress chips (emphasis=primary = current) segment_wheel: a wheel of equal segments around a center - peer categories in the round (composition, not flow) status_dashboard: initiatives/workstreams tracked by status, owner, progress strategic_fork: one origin splitting into two mutually exclusive paths, one recommended swimlane_flow: actor/function lanes by phases, task cells, handoffs across lanes swot: the four-quadrant strengths / weaknesses / opportunities / threats grid system_flow_map: architecture/system components: panels with internals (edges optional) or nodes wired by directed arrows takeaway_stack: a title plus a few supporting points, each with one line of detail (executive summary, key findings); optional closing ask timeline_roadmap: milestones/phases laid out along a time axis trend_chart: one or more series plotted over time value_chain: support bands over primary activity columns flowing into a goal arrowhead (data.support = the bands) visual_showcase: one dominant screenshot/image with numbered callouts pointing into it waterfall_bridge: a start value bridged to an end value by plus/minus contributions

Exact per-form data shapes: browse_catalog(type=schema, family=) — the generated,always-current JSON Schema + a worked example. (List-shaped forms take blocks: [{"label","sub","detail":[str],"emphasis"}]; structured forms take typed data.)

Escape modes: mode=code (caller-supplied python-pptx in sandbox, $0.05 — use for forms the menu cannot express: calendars, custom diagrams); mode=status (poll a job, free). Image-led asks (photo covers, full-bleed visuals): hero_statement + image_prompt (+$0.05) or image_src.

Inputs: code, data, date, form, +38 more.

manage_accountAccount & HistoryA
Destructive
Inspect

SlideForge account for PowerPoint generation: balance, billing, job history, feedback, data controls. All free. Actions: status (balance+plan), usage (spend breakdown), jobs (history), job (single job detail — slide jobs include quality_warnings[]; deck jobs add slides_completed/slides_failed/failed_slides[]), feedback (submit), feedback_list (read your reports back: status + resolution), onboarding (capabilities overview), topup (Stripe checkout link; wallet credits automatically), webhooks/webhook_add/webhook_remove/webhook_test (push endpoint instead of polling to terminal), download_url (fresh short-TTL PPTX link for an owned job — when a result carries no inline URL), security_status (retention + access-model + deletion posture), delete_job (irreversible: job + versions + files) Action delete_asset irreversibly deletes a user-owned uploaded/generated image asset.

Inputs: action (required), url, days, slug, +13 more.

plan_slidePlan a Slide - Form + Variant CandidatesA
Read-onlyIdempotent
Inspect

Plan a PowerPoint slide before rendering (free): send a short brief, get ranked candidates + a separated verdict — route (which slide: selected|needs_confirmation|ambiguous), input (can it render: ready|extractable_from_brief|needs_structured_data) and next_action. Free (one embedding). Then call create_slide with the chosen form(+variant). route.confidence: calibrated = measured P(route correct) with label high/medium/low cut on it; retrieval_score/retrieval_margin = the raw family-aggregated classifier values (not probabilities; margin can be negative when families contest); source = classifier | structural_router (LLM-rescued). candidate_margin on the top candidate = literal gap between the two shown scores.

Inputs: brief (required), top, escalate, variant_policy.

translate_deckTranslate PPTXAInspect

Translate a PowerPoint (.pptx) deck preserving all formatting. $0.02/slide. Supports 32 languages (Latin, Cyrillic, Greek scripts). Provide job_id (from a previous create_slide/create_deck), pptx_url, or pptx_base64.

Inputs: target_language (required), name, job_id, pptx_url, +6 more.

upload_assetUpload or Generate AssetAInspect

Upload assets for PowerPoint (.pptx) generation: company template, logo, image, or document — or AI-generate an image.

Purposes: • logo — company logo for chrome (PNG/JPG/SVG, max 5MB) → logo_id • image — image for the Image component (max 10MB) → asset_id • theme — company template PPTX → theme_id; slides with it render NATIVELY on the template (masters/layouts/chrome) • generate_image — AI-generate via prompt → asset_id ($0.05) • translate — PPTX to translate → deck job_id ($0.02/slide; requires target_language) • pdf — PDF → editable slides; pass target_language to also translate • recreate — image OF a slide → editable PPTX slide ($0.10; honest annotate/preserve fallback, refusals free). Use image to just place a picture

Files >3MB (pdf/translate/theme) — and recreate on chat hosts — omit data: a drop-zone appears in the result card; bytes never pass through the agent.

Inputs: purpose (required), data, size, model, +6 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    A4.4/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool has a clearly distinct role: catalog exploration, slide planning, single-slide rendering, deck rendering, translation, asset upload, and account management. There is no meaningful overlap that would mislead an agent into picking the wrong tool.

    Naming Consistency5/5

    All tool names follow the same verb_noun snake_case pattern: browse_catalog, plan_slide, create_slide, create_deck, translate_deck, upload_asset, manage_account. The naming is uniform and predictable.

    Tool Count5/5

    Seven tools is well-scoped for a PowerPoint generation server. Each tool covers a necessary and distinct part of the workflow without redundancy or bloat.

    Completeness4/5

    The surface covers the full creation lifecycle: planning, single-slide generation, multi-slide decks, translation, asset ingestion, and account/job management. Minor gaps like no dedicated asset-listing tool or in-place deck editing exist, but agents can work around them via manage_account and browse_catalog.

    Maintenance

    ActivityStale
    ResponsivenessLimited data

    Resources

    Related MCP Connectors

    Related MCP Servers

    Appeared in Searches