document-creation-mcp

MCP server for AI-driven document creation, starting with PowerPoint decks.

The server is the execution layer: it builds .pptx files from a structured slide plan, applies consistent design themes, and auto-generates images via your existing ComfyUI MCP server. The orchestrating model (e.g. in Open WebUI) does any web research and composes the slide plan, then calls these tools.

Tools

create_presentation will auto-generate any image that has an image.prompt (using ComfyUI), and embed existing files/URLs when image.source is set.

Related MCP server: office-mcp-server

Install

python -m venv .venv && source .venv/bin/activate
pip install -e .

Configure (environment variables)

Run

document-creation-mcp            # stdio transport (recommended for Open WebUI)
# or: python -m document_creation_mcp.server

Docker

Build and run the server inside a container.

# Build the image
docker build -t document-creation-mcp .

# Run with streamable-http transport (default in the Dockerfile)
docker run -p 8000:8000 \
  -e COMFY_MCP_COMMAND='["python","-m","comfy_mcp_server"]' \
  -v "$(pwd)/output:/app/output" \
  document-creation-mcp

Or use the provided Compose file:

docker compose up --build

The container serves on port 8000 using streamable-http by default. Generated .pptx files are written to /app/output (mount ./output to retrieve them). Override DOC_MCP_TRANSPORT=stdio if you instead want the container spawned as a stdio MCP server by its parent.

Open WebUI setup

1. Start your ComfyUI MCP server separately (the command above must reach it).

2. In Open WebUI → Admin → Tools → Add MCP server, point at this server (stdio command: document-creation-mcp, or an SSE URL if you wrap it).

3. The model can now call create_presentation (after doing web search and drafting the plan) and generate_image for bespoke visuals.

When running this server in Docker, register it as an HTTP/SSE MCP server pointing at http://<host>:8000/mcp (streamable-http) or /sse instead of the stdio command.

Connecting over HTTP (Open WebUI / MetaMCP)

• The server only listens for sse / streamable-http when DOC_MCP_TRANSPORT is set to one of those (the Docker image defaults to streamable-http).

• It must be reachable from the client: set DOC_MCP_HOST=0.0.0.0 and publish the port (e.g. ports: ["3335:3335"] in Compose with DOC_MCP_PORT=3335). A Connection refused means the container isn't up, isn't on that port, or is bound to 127.0.0.1.

• The client URL must include the endpoint path:

  • default → http://<host>:<port>/mcp

  • if your client POSTs to the server root (some MetaMCP setups do), set DOC_MCP_STREAMABLE_HTTP_PATH=/ and use http://<host>:<port>/.

  • A 404 Not Found on a POST means the path didn't match — adjust DOC_MCP_STREAMABLE_HTTP_PATH or add /mcp to the URL. Intermittent 404s on /mcp (especially from different client IPs) are usually stateful-session rejects from a proxy; set DOC_MCP_STATELESS_HTTP=true (the default) so each request is handled without a session.

Retrieving generated files

create_presentation writes the .pptx to DOC_MCP_OUTPUT_DIR and returns its path. Because the server runs in a container, that path is internal — to get the file:

• MinIO (best for shared access): set MINIO_ENDPOINT (with keys). The tool uploads the file and returns a download.url — a direct link if MINIO_PUBLIC_URL is set, otherwise a presigned GET URL. Anyone with the link can fetch the deck; the container needs the minio extra installed (the Docker image includes it).

• Base64 (no infra): keep DOC_MCP_RETURN_BASE64=true (default). The tool result includes a download field with filename, mime_type and base64 data. Save/decode that to get the file through the chat client (Open WebUI).

• Mounted volume: mount DOC_MCP_OUTPUT_DIR (the Compose file mounts ./output:/app/output) and read ./output/<name>.pptx from the host, then set DOC_MCP_RETURN_BASE64=false to avoid the base64 in context.

The download object may contain any combination of url, data and minio_error (if an upload failed but the deck was still built).

Themes

Factory themes ship inside the package at src/document_creation_mcp/themes/*.yaml (dark_tech, corporate, minimal, academic), so they are always available after install, including in Docker.

name: dark_tech
colors:
  background: "#0B0E14"
  primary: "#4F8CFF"
  accent: "#00E0C6"
  text: "#E6EAF2"
  muted: "#8A93A6"
fonts:
  heading: "Montserrat"
  body: "Inter"
image_style: "cinematic, neon accents, dark moody background, 8k, highly detailed"
layout_default: title_and_content
logo: null

image_style is appended to every generated image prompt for visual consistency.

Add or override themes: set DOC_MCP_THEME_DIR to a directory of *.yaml files (e.g. a mounted volume in Docker). Its themes are merged on top of the bundled ones, so a file with the same name overrides a factory theme.

Note: style_reference_image / controlnet.reference_image paths are resolved at runtime — in Docker, mount those assets and use absolute paths (or paths relative to the container working directory). The optional advanced workflow COMFY_API_WORKFLOW similarly needs to be mounted into the container.

To refresh after editing theme files, the server reloads them on startup; there is also a list_themes() tool to confirm what is loaded.

Automatic, consistent image generation (no workflow files)

IMAGE_BACKEND=comfy_api drives ComfyUI directly and needs no workflow JSON. On first generation it queries the instance's /object_info to discover every installed model — checkpoints, VAE, LoRA, ControlNet, IP-Adapter, CLIP-Vision and upscalers — then assembles a consistency pipeline in code using only what is present:

Checkpoint ─► [IP-Adapter] ─► [ControlNet] ─► KSampler ─► VAEDecode
                                                    │
                                           [Upscale] ─► SaveImage

Bracketed nodes are inserted conditionally, so a bare text-to-image graph is used when only a checkpoint is available, and the full IP-Adapter + ControlNet + upscale pipeline kicks in automatically as more models are installed. There is nothing to configure by hand.

What to install (more = more consistent)

How consistency is enforced

1. Auto style reference. If a theme sets style_reference_image it is used; otherwise the backend generates one anchor image per deck from the theme's image_style and feeds it to IP-Adapter, so all slides share a look with no supplied asset.

2. Per-role presets (ImageSpec.target):

   • background → stronger ControlNet + auto dim/blur post-process for legibility.

   • content → balanced style + composition lock.

   • icon → lighter composition control, placed as a small top-right asset.

3. Shared negative prompt + palette. The deck/theme negative_prompt and the theme image_style suffix are applied to every prompt.

4. Graceful degradation. Missing ControlNet / IP-Adapter / upscaler → that stage is skipped; the graph always submits successfully.

Optional theme tuning

name: dark_tech
image_style: "cinematic, neon accents, dark moody background, 8k, highly detailed"
style_reference_image: "themes/refs/dark_tech_style.png"  # optional; auto-generated if omitted
ip_adapter_weight: 0.7
ip_adapter_weight_type: null   # optional; omit so the node uses its own default
                               # (enum varies between IP-Adapter versions)
controlnet:
  enabled: true
  type: depth          # depth | canny | openpose | tile
  strength: 0.6
  reference_image: "themes/refs/dark_tech_comp.png"
upscale_model: "4x-UltraSharp.pth"   # optional; auto-selected if omitted
negative_prompt: "watermark, text, blurry, low quality, jpeg artifacts"
background_post: "dim"   # light blur + dark overlay so text stays readable

Set COMFY_API_AUTODISCOVER=false only if you want to pin specific model names via the COMFY_API_* env vars instead of auto-detection.

Slide plan schema

create_presentation takes the plan as a JSON object (not a string). Slide text is given as bullets (a list of strings) or content (a string, which is split on newlines, or a list).

{
  "title": "Deck title",
  "theme": "dark_tech",
  "output_filename": "my_deck",
  "bucket": "presentations",
  "slides": [
    {"title": "Intro", "layout": "title", "subtitle": "An AI deck"},
    {"title": "Topic", "bullets": ["Point 1"], "image": {"prompt": "futuristic city"}},
    {"title": "Deep dive", "layout": "image_full", "image": {"prompt": "data flow"}}
  ]
}

Layouts: title, title_and_content, two_column, image_full, section. The optional bucket field sets the MinIO bucket for this deck (overrides MINIO_BUCKET env).