Quickstart · Templates · Docs · Youtube · Discord

Open-Source AI Presentation Generator and API (Gamma, Canva, Beautiful AI, Decktopus, Presentations AI Alternative)

Discover what Presenton can do from AI-powered presentation generation to editing, exporting, and flexible model providers.

▶ Watch Presenton in Action

✨ Why Presenton

No SaaS lock-in · No forced subscriptions · Full control over models and data

What makes Presenton different?

Use Fully self-hosted in Web through Docker Package
Or Download Desktop App (Mac, Windows & Linux)
Works with Ollama, LM Studio, OpenAI, Gemini, Vertex AI, Azure OpenAI, Amazon Bedrock, Fireworks, Together AI, Anthropic, or any other OpenAI compatible providers
Comes with AI Presentation Generation API
Fully open-source (Apache 2.0)
Works with your own design/templates
Fully editable PPTX export

[!TIP] Star us! A ⭐ shows your support and encourages us to keep building! 😇

Presenton

🎛 Features

Create presentations from a prompt, an uploaded document, or your own PowerPoint design. Choose from built-in templates, bring your preferred AI provider and API key, polish manually with drag-edit interface and export a fully editable deck.

Drag-and-drop editing in the Presenton slide editor

Presenton features: custom designs, AI generation, bring your own API key, and built-in templates

Create presentations with your existing ChatGPT subscription: secure and private, with instant access and no API keys

🎨 In-Built AI Presentation Templates for PowerPoint

Browse in-built AI presentation templates for pitch decks, business reports, executive updates, educational presentations, and more. Preview each editable slide layout, choose a design, and use Presenton to generate fully editable PowerPoint (.pptx) or PDF presentations from a prompt or document.

_{Momentum Business Presentation Template — sales reports, strategy decks, and data storytelling Preview Momentum business template ↗}	_{Dynamic Creative Presentation Template — proposals, visual stories, and high-impact decks Preview Dynamic presentation template ↗}	_{Executive PowerPoint Template — leadership updates, strategic plans, and decision-ready reports Preview Executive PowerPoint template ↗}
_{General Presentation Template — adaptable layouts for business, education, and everyday topics Preview General presentation template ↗}	_{Modern Pitch Deck Template — contemporary slides for startups, products, and portfolios Preview Modern pitch deck template ↗}	_{Standard Business Presentation Template — professional reports, proposals, and company decks Preview Standard business template ↗}

Browse all free AI presentation templates → · Create an AI-ready PowerPoint template from your PPTX →

💻 Presenton Desktop

Create AI-powered presentations using your own model provider (BYOK) or run everything locally on your own machine for full control and data privacy.

Available Platforms

Platform	Architecture	Package	Download
macOS	Apple Silicon / Intel	`.dmg`	Download ↗
Windows	x64	`.exe`	Download ↗
Linux	x64	`.deb`	Download ↗

Deploy to Cloud Providers

Presenton gives you complete control over your AI presentation workflow. Choose your models, customize your experience, and keep your data private.

Custom Templates & Themes — Create unlimited presentation designs with HTML and Tailwind CSS
AI Template Generation — Create presentation templates from existing Powerpoint documents.
Flexible Generation — Build presentations from prompts or uploaded documents
Export Ready — Save as PowerPoint (PPTX) and PDF with professional formatting
Built-In MCP Server — Generate presentations over Model Context Protocol
Bring Your Own Key — Use your own API keys for OpenAI, Google Gemini, Vertex AI, Azure OpenAI, Anthropic Claude, or any compatible provider. Only pay for what you use, no hidden fees or subscriptions.
Ollama Integration — Run open-source models locally with full privacy
OpenAI API Compatible — Connect to any OpenAI-compatible endpoint with your own models
Multi-Provider Support — Mix and match text and image generation providers
Versatile Image Generation — Choose from DALL-E 3, Gemini Flash, Pexels, or Pixabay
Rich Media Support — Icons, charts, and custom graphics for professional presentations
Runs Locally — All processing happens on your device, no cloud dependencies
API Deployment — Host as your own API service for your team
Multi-User Workspaces — Give each user a private workspace and manage accounts from a built-in admin panel
Fully Open-Source — Apache 2.0 licensed, inspect, modify, and contribute
Docker Ready — One-command deployment with GPU support for local models
Electron Desktop App — Run Presenton as a native desktop application on Windows, macOS, and Linux (no browser required)
Sign in with ChatGPT — Use your free or paid ChatGPT account to sign in and start creating presentations instantly — no separate API key required

☁️ Presenton Cloud

Run Presenton directly in your browser — no installation, no setup required. Start creating presentations instantly from anywhere.

⚡ Running Presenton

You can run Presenton in two ways: Docker for a one-command setup without installing a local dev stack, or the Electron desktop app for a native app experience (ideal for development or offline use).

Option 1: Electron (Desktop App)

Run Presenton as a native desktop application. LLM and image provider (API keys, etc.) can be configured in the app. The same environment variables used for Docker apply when running the bundled backend.

Prerequisites: Node.js (LTS), npm, Python 3.11, and uv (for the shared FastAPI backend in servers/fastapi).

Setup (First Time)
```
cd electron
npm run setup:env
```
This installs Node dependencies, runs uv sync in the FastAPI server, and installs Next.js dependencies.
Run in Development
```
npm run dev
```
This compiles TypeScript and starts Electron. The backend and UI run locally inside the desktop window.
Build Distributable (Optional) To create installers for Windows, macOS, or Linux:
```
npm run build:all
npm run dist
```
Output files are written to electron/dist (or as configured in your electron-builder settings).

For a public macOS DMG outside the Mac App Store, use APPLE_KEYCHAIN_PROFILE="presenton-notary" npm run build:all:mac:signed from electron/ after the one-time Developer ID and notarization setup in docs/macos/dev/direct-distribution.md.

Option 2: Docker

Start Presenton Linux/MacOS (Bash/Zsh Shell):

docker run -it --name presenton -p 5001:80 -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Windows (PowerShell):

docker run -it --name presenton -p 5001:80 -v "${PWD}\app_data:/app_data" ghcr.io/presenton/presenton:latest

Open Presenton

Open http://localhost:5001 in the browser of your choice to use Presenton.

Note: You can replace 5001 with any other port number of your choice to run Presenton on a different port number. If you use Docker Compose, set PRESENTON_HTTP_HOST_PORT, for example PRESENTON_HTTP_HOST_PORT=8080 docker compose up production.

⚙️ Deployment Configurations

The lists below match the environment variables forwarded in this repository’s docker-compose.yml (production, production-gpu, development, and development-gpu). Put values in a .env file next to the compose file, or export them before docker compose up. The Electron app backend can read the same names when run outside Docker.

Other optional variables exist in code (for example advanced Mem0 paths, LiteParse runners, or FAST_API_INTERNAL_URL when Next.js and FastAPI are not same-origin); they are not wired in docker-compose.yml. Supported names are discoverable from servers/fastapi/utils/get_env.py and the Next.js server utilities under servers/nextjs/.

LLM and API keys

CAN_CHANGE_KEYS=[true/false]: Set to false if you want to keep API keys hidden and make them unmodifiable.
LLM=[openai/deepseek/google/vertex/azure/bedrock/openrouter/fireworks/together/cerebras/anthropic/litellm/lmstudio/ollama/custom/codex]: Select the text LLM.
OPENAI_API_KEY: Required if LLM is openai.
OPENAI_MODEL: Required if LLM is openai (default: gpt-4.1).
DEEPSEEK_API_KEY: Required if LLM is deepseek.
DEEPSEEK_MODEL: Required if LLM is deepseek (default: deepseek-chat).
DEEPSEEK_BASE_URL: Optional if LLM is deepseek (default: https://api.deepseek.com).
GOOGLE_API_KEY: Required if LLM is google.
GOOGLE_MODEL: Required if LLM is google (default: models/gemini-2.0-flash).
VERTEX_MODEL: Required if LLM is vertex (default: gemini-2.5-flash).
VERTEX_API_KEY: Optional auth path for LLM=vertex (Vertex Express).
VERTEX_PROJECT / VERTEX_LOCATION: Optional auth path for LLM=vertex when using GCP project credentials (do not combine with VERTEX_API_KEY).
VERTEX_BASE_URL: Optional Vertex gateway/base URL override.
AZURE_OPENAI_MODEL: Required if LLM is azure (deployment/model name).
AZURE_OPENAI_API_KEY: Required if LLM is azure.
AZURE_OPENAI_API_VERSION: Required if LLM is azure (for example 2024-10-21).
AZURE_OPENAI_ENDPOINT / AZURE_OPENAI_BASE_URL: At least one is required if LLM is azure.
AZURE_OPENAI_DEPLOYMENT: Optional deployment override for LLM is azure.
BEDROCK_REGION: Optional if LLM is bedrock (default: us-east-1).
BEDROCK_MODEL: Required if LLM is bedrock. Use a standard model ID (example: us.anthropic.claude-3-5-haiku-20241022-v1:0) or a full inference profile ARN for newer models (example: Claude Sonnet 4.6). Passed through to Bedrock Converse as modelId. See Amazon Bedrock guide.
BEDROCK_API_KEY: Optional if LLM is bedrock (API key auth; alternative to AWS keys).
BEDROCK_AWS_ACCESS_KEY_ID / BEDROCK_AWS_SECRET_ACCESS_KEY: Required together if LLM is bedrock and BEDROCK_API_KEY is not set.
BEDROCK_AWS_SESSION_TOKEN: Optional session token for LLM is bedrock.
BEDROCK_PROFILE_NAME: Optional AWS profile name for LLM is bedrock.
OPENROUTER_API_KEY: Required if LLM is openrouter.
OPENROUTER_MODEL: Required if LLM is openrouter (default: openai/gpt-4o).
OPENROUTER_BASE_URL: Optional if LLM is openrouter (default: https://openrouter.ai/api/v1).
FIREWORKS_API_KEY: Required if LLM is fireworks.
FIREWORKS_MODEL: Required if LLM is fireworks (example: accounts/fireworks/models/llama-v3p1-8b-instruct).
FIREWORKS_BASE_URL: Optional if LLM is fireworks (default: https://api.fireworks.ai/inference/v1).
TOGETHER_API_KEY: Required if LLM is together.
TOGETHER_MODEL: Required if LLM is together (example: openai/gpt-oss-20b).
TOGETHER_BASE_URL: Optional if LLM is together (default: https://api.together.ai/v1).
CEREBRAS_API_KEY: Required if LLM is cerebras.
CEREBRAS_MODEL: Required if LLM is cerebras (default: llama-3.3-70b).
CEREBRAS_BASE_URL: Optional if LLM is cerebras (default: https://api.cerebras.ai/v1).
ANTHROPIC_API_KEY: Required if LLM is anthropic.
ANTHROPIC_MODEL: Required if LLM is anthropic (default: claude-3-5-sonnet-20241022).
CODEX_MODEL: Required if LLM is codex (Codex OAuth flow; compose maps host port 1455 for the callback).
CUSTOM_LLM_URL: OpenAI-compatible base URL if LLM is custom.
CUSTOM_LLM_API_KEY: API key if LLM is custom.
CUSTOM_MODEL: Model id if LLM is custom.
LITELLM_BASE_URL: LiteLLM proxy or gateway base URL if LLM is litellm.
LITELLM_API_KEY: Optional API key if LLM is litellm.
LITELLM_MODEL: Required if LLM is litellm (default: gpt-4.1).
LMSTUDIO_BASE_URL: Optional LM Studio base URL if LLM is lmstudio (default: http://localhost:1234/v1; /v1 is auto-appended when omitted).
LMSTUDIO_API_KEY: Optional API key if LLM is lmstudio.
LMSTUDIO_MODEL: Required if LLM is lmstudio (example: openai/gpt-oss-20b).
DISABLE_THINKING=[true/false]: If true, disables “thinking” for providers that support it (including DeepSeek).
WEB_GROUNDING=[true/false]: If true, enables web search by default.
WEB_SEARCH_PROVIDER=[auto/native/searxng/tavily/exa]: Selects the web search mode. auto uses native search for OpenAI, Google, and Anthropic, and otherwise leaves web search off unless you choose an external provider.

WEB_SEARCH_MAX_RESULTS: Maximum external search results to add to model context (default 5, maximum 10).
SEARXNG_BASE_URL: Base URL for a self-hosted SearXNG instance.
TAVILY_API_KEY, EXA_API_KEY: Credentials for optional hosted search APIs.

EXTENDED_REASONING=[true/false]: Enables extended reasoning where supported by the configured stack.

Ollama

Use when LLM is ollama:

OLLAMA_URL: Base URL of the Ollama HTTP API (e.g. http://host.docker.internal:11434 from Docker).
OLLAMA_MODEL: Model name in Ollama (e.g. llama3.2:3b).
START_OLLAMA=[true/false]: Container entrypoint (start.js): optional install + ollama serve. Default false (development / production compose).

Presentation memory (Mem0 OSS)

Mem0 uses local Qdrant + SQLite (OSS); memory is scoped per presentation.

By default the Docker runtime now points Mem0 at a local Ollama-compatible LLM endpoint, so it no longer needs an OpenAI key just to initialize. If you want to use OpenAI instead, set MEM0_LLM_BASE_URL/MEM0_LLM_API_KEY to your OpenAI-compatible endpoint and key. Docker images install the default spaCy model (en_core_web_sm) during build so Mem0 can start without extra setup on each run.

Variable	Purpose
MEM0_ENABLED	true/false (compose default true).
MEM0_LLM_MODEL	Mem0 LLM model name (compose default `llama3.1:latest` or `OLLAMA_MODEL`).
MEM0_LLM_API_KEY	Mem0 LLM API key placeholder for OpenAI-compatible clients (compose default `ollama`).
MEM0_LLM_BASE_URL	Mem0 LLM base URL (compose default `OLLAMA_URL` or `http://host.docker.internal:11434`).
MEM0_DIR	Root directory (compose default `/app_data/mem0`).
MEM0_EMBEDDER_PROVIDER	Embedder backend (compose default `fastembed`).
MEM0_EMBEDDER_MODEL	Model id (compose default `BAAI/bge-small-en-v1.5`).
MEM0_EMBEDDING_DIMS	Vector size (compose default 384).
MEM0_SPACY_MODEL	Optional spaCy model override (default `en_core_web_sm`).
MEM0_REQUIRE_SPACY_MODEL	Keep as true (default). Set to false only if you intentionally want Mem0 to run without spaCy lemmatization.

Document parsing (LiteParse)

Variable	Purpose
LITEPARSE_DPI	OCR render DPI (compose default 120).
LITEPARSE_NUM_WORKERS	Worker count (compose default 1).

Database

DATABASE_URL: SQLAlchemy URL; if unset, the app falls back to SQLite under app data.
MIGRATE_DATABASE_ON_STARTUP: Compose sets true for all services so migrations run on startup.

Image generation

These variables match docker-compose.yml. IMAGE_PROVIDER selects the backend (pexels, pixabay, gemini_flash, nanobanana_pro, dall-e-3, gpt-image-1.5, comfyui, open_webui). Use OPENAI_API_KEY for OpenAI image modes and GOOGLE_API_KEY for Gemini image modes (same keys as the LLM section).

DISABLE_IMAGE_GENERATION=[true/false]: Disable slide image generation.
ENABLE_PARALLEL_IMAGE_GENERATION=[true/false]: Allow concurrent image provider requests (default true). Set to false to generate images one at a time when the provider has strict rate limits.
IMAGE_PROVIDER: Provider id (see enum above).
PEXELS_API_KEY: Pexels stock images.
PIXABAY_API_KEY: Pixabay stock images.
DALL_E_3_QUALITY=[standard/hd]: Optional for dall-e-3 (default standard).
GPT_IMAGE_1_5_QUALITY=[low/medium/high]: Optional for gpt-image-1.5 (default medium).
COMFYUI_URL / COMFYUI_WORKFLOW: Self-hosted ComfyUI workflow JSON.
OPEN_WEBUI_IMAGE_URL / OPEN_WEBUI_IMAGE_API_KEY: Open WebUI–compatible image endpoint.
OPENAI_COMPAT_IMAGE_BASE_URL / OPENAI_COMPAT_IMAGE_API_KEY / OPENAI_COMPAT_IMAGE_MODEL: Required if using openai_compatible to send image requests to any OpenAI-compatible /v1/images/* endpoint (LiteLLM, Azure, vLLM Gateways, etc.).

The parallel image generation option applies everywhere images are generated: initial presentation generation, slide editing and regeneration, direct image requests, and assistant image tools.

Telemetry

DISABLE_ANONYMOUS_TRACKING=[true/false]: Set to true to disable anonymous telemetry.

Multi-user authentication

Presenton supports multiple accounts with a private workspace for each user. The first account becomes the primary administrator and can create, reset, or remove other accounts from Admin → Users.

Existing single-user installations are upgraded automatically: the current account becomes the primary administrator, while its presentations, templates, tasks, and other owned data stay attached to the same account.

Set up the primary administrator

On a new installation, open Presenton and follow the account setup screen. For an unattended Docker deployment, you can create the primary administrator on first boot with environment variables:

docker run -it --name presenton \
  -p 5001:80 \
  -e AUTH_USERNAME=admin \
  -e AUTH_PASSWORD=change-this-password \
  -v "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest

Usernames must contain at least 3 characters, and new passwords must contain at least 8 characters. Older six- or seven-character passwords remain valid after an upgrade.

Authentication environment variables

Variable	Purpose
AUTH_USERNAME	Username used to create the primary administrator on first boot. It can also change the username during a rotation or recovery.
AUTH_PASSWORD	Password used for first-time setup, rotation, or recovery. Required when using either flag below.
AUTH_OVERRIDE_FROM_ENV=[true/false]	Replace the primary administrator's credentials from the environment on the next startup. Use this for a deployment-managed credential rotation.
RESET_AUTH=[true/false]	Recover access to the existing primary administrator without replacing the account or its data.

To rotate credentials from the environment:

docker stop presenton
docker rm presenton
docker run -it --name presenton \
  -p 5001:80 \
  -e AUTH_USERNAME=admin \
  -e AUTH_PASSWORD=new-secure-password \
  -e AUTH_OVERRIDE_FROM_ENV=true \
  -v "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest

For account recovery, use the same command with RESET_AUTH=true instead of AUTH_OVERRIDE_FROM_ENV=true. Both operations preserve the administrator's user ID and owned data, and invalidate existing browser sessions and API keys. Remove the one-time flag after the successful startup.

[!IMPORTANT] Do not remove authentication fields from app_data/userConfig.json to reset access. Presenton stores a hashed recovery copy of the primary administrator credentials and the session-signing secret there. Use the recovery variables above to preserve the database account and its ownership links.

To sign out, open Settings → Other → Sign out.

MCP authentication

When auth is enabled, the MCP endpoint at /mcp requires an admin-generated Presenton access key. Browser JWT cookies are not accepted as MCP credentials.

The Presenton administrator opens Admin → API keys, chooses Generate key, and securely gives that key to the MCP user. The MCP user does not need a Presenton account or an admin browser login.
Configure the MCP client to send the generated sk-presenton-... key on every request:

{
  "servers": {
    "presenton": {
      "url": "http://localhost:5001/mcp",
      "type": "http",
      "headers": {
        "Authorization": "Bearer sk-presenton-REPLACE_WITH_YOUR_KEY"
      }
    }
  },
  "inputs": []
}

Notes:

This example uses VS Code's .vscode/mcp.json format. Use the equivalent static-header configuration for other MCP clients.
Access keys authenticate API/MCP requests only; they cannot sign in to the Presenton browser UI.
Revoking the key from the admin panel takes effect immediately.
MCP is not available in the Electron desktop app (PRESENTON_ELECTRON=true). Electron runs with DISABLE_AUTH=true by default, and the MCP server is disabled there to avoid auth conflicts.

Note: LLM and image variables above are forwarded from docker-compose.yml when set in .env.

Docker Run Examples by Provider

Same variables as compose; use -e instead of .env when running docker run directly.

Using OpenAI

docker run -it --name presenton -p 5001:80 -e LLM="openai" -e OPENAI_API_KEY="******" -e IMAGE_PROVIDER="dall-e-3" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Google

docker run -it --name presenton -p 5001:80 -e LLM="google" -e GOOGLE_API_KEY="******" -e IMAGE_PROVIDER="gemini_flash" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Vertex AI (API key mode)

docker run -it --name presenton -p 5001:80 -e LLM="vertex" -e VERTEX_API_KEY="******" -e VERTEX_MODEL="gemini-2.5-flash" -e IMAGE_PROVIDER="gemini_flash" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Azure OpenAI

docker run -it --name presenton -p 5001:80 -e LLM="azure" -e AZURE_OPENAI_API_KEY="******" -e AZURE_OPENAI_MODEL="gpt-4.1" -e AZURE_OPENAI_API_VERSION="2024-10-21" -e AZURE_OPENAI_ENDPOINT="https://YOUR-RESOURCE.openai.azure.com" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Amazon Bedrock (on-demand model ID) — see docs/amazon-bedrock.md for inference profiles, IAM, and troubleshooting.

docker run -it --name presenton -p 5001:80 -e LLM="bedrock" -e BEDROCK_REGION="us-east-1" -e BEDROCK_AWS_ACCESS_KEY_ID="******" -e BEDROCK_AWS_SECRET_ACCESS_KEY="******" -e BEDROCK_MODEL="us.anthropic.claude-3-5-haiku-20241022-v1:0" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Amazon Bedrock (inference profile ARN, e.g. Claude Sonnet 4.6)

docker run -it --name presenton -p 5001:80 -e LLM="bedrock" -e BEDROCK_REGION="us-east-1" -e BEDROCK_AWS_ACCESS_KEY_ID="******" -e BEDROCK_AWS_SECRET_ACCESS_KEY="******" -e BEDROCK_MODEL="arn:aws:bedrock:us-east-1:YOUR_ACCOUNT_ID:inference-profile/us.anthropic.claude-sonnet-4-6" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Fireworks

docker run -it --name presenton -p 5001:80 -e LLM="fireworks" -e FIREWORKS_API_KEY="******" -e FIREWORKS_MODEL="accounts/fireworks/models/llama-v3p1-8b-instruct" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Together AI

docker run -it --name presenton -p 5001:80 -e LLM="together" -e TOGETHER_API_KEY="******" -e TOGETHER_MODEL="openai/gpt-oss-20b" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Ollama

docker run -it --name presenton -p 5001:80 -e LLM="ollama" -e OLLAMA_MODEL="llama3.2:3b" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="*******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using Anthropic

docker run -it --name presenton -p 5001:80 -e LLM="anthropic" -e ANTHROPIC_API_KEY="******" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using LM Studio (local)

docker run -it --name presenton -p 5001:80 -e LLM="lmstudio" -e LMSTUDIO_BASE_URL="http://host.docker.internal:1234" -e LMSTUDIO_MODEL="openai/gpt-oss-20b" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Using OpenAI Compatible LLM API

docker run -it -p 5001:80 -e CAN_CHANGE_KEYS="false"  -e LLM="custom" -e CUSTOM_LLM_URL="http://*****" -e CUSTOM_LLM_API_KEY="*****" -e CUSTOM_MODEL="llama3.2:3b" -e IMAGE_PROVIDER="pexels" -e  PEXELS_API_KEY="********" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

Running Presenton with GPU Support To use GPU acceleration with Ollama models, you need to install and configure the NVIDIA Container Toolkit. This allows Docker containers to access your NVIDIA GPU. Once the NVIDIA Container Toolkit is installed and configured, you can run Presenton with GPU support by adding the --gpus=all flag:
```
docker run -it --name presenton --gpus=all -p 5001:80 -e LLM="ollama" -e OLLAMA_MODEL="llama3.2:3b" -e IMAGE_PROVIDER="pexels" -e PEXELS_API_KEY="*******" -e CAN_CHANGE_KEYS="false" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest
```

Using an OpenAI-Compatible Image Provider

This routes all slide image requests through your OpenAI-compatible gateway (LiteLLM, Azure, vLLM, etc.) while keeping the text LLM configuration independent:

docker run -it --name presenton -p 5001:80 -e IMAGE_PROVIDER="openai_compatible" -e OPENAI_COMPAT_IMAGE_BASE_URL="https://proxy.example.com/v1" -e OPENAI_COMPAT_IMAGE_API_KEY="******" -e OPENAI_COMPAT_IMAGE_MODEL="gpt-image-1" -v "./app_data:/app_data" ghcr.io/presenton/presenton:latest

✨ Generate Presentation via API

Generate Presentation

Endpoint: /api/v1/ppt/presentation/generate
Method: POST
Content-Type: application/json

Authentication (API key):
All /api/v1/ routes except the public authentication endpoints require authentication. An administrator creates an access key under Admin → API keys. Send that sk-presenton-... key as Authorization: Bearer YOUR_KEY. API keys act as their owning user and cannot call browser-session-only administrator endpoints.

Request Body

Parameter	Type	Required	Description
`content`	string	Yes	Main content used to generate the presentation.
`slides_markdown`	string[] \| null	No	Provide custom slide markdown instead of auto-generation.
`instructions`	string \| null	No	Additional generation instructions.
`tone`	string	No	Text tone (default: `"default"`). Options: `default`, `casual`, `professional`, `funny`, `educational`, `sales_pitch`
`verbosity`	string	No	Content density (default: `"standard"`). Options: `concise`, `standard`, `text-heavy`
`web_search`	boolean	No	Enable web search grounding (default: `false`).
`n_slides`	integer	No	Number of slides to generate (default: `8`).
`language`	string	No	Presentation language (default: `"English"`).
`template`	string	No	Template name (default: `"general"`).
`include_table_of_contents`	boolean	No	Include table of contents slide (default: `false`).
`include_title_slide`	boolean	No	Include title slide (default: `true`).
`files`	string[] \| null	No	Files to use in generation. Upload first via `/api/v1/ppt/files/upload`.
`export_as`	string	No	Export format (default: `"pptx"`). Options: `pptx`, `pdf`

Response

{
  "presentation_id": "string",
  "path": "string",
  "edit_path": "string"
}

Example (curl + API key)

curl \
  -X POST http://localhost:5001/api/v1/ppt/presentation/generate \
  -H "Authorization: Bearer sk-presenton-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
   "content": "Introduction to Machine Learning",
    "n_slides": 5,
    "language": "English",
    "template": "general",
    "export_as": "pptx"
  }'

Example Response

{
  "presentation_id": "d3000f96-096c-4768-b67b-e99aed029b57",
  "path": "/app_data/d3000f96-096c-4768-b67b-e99aed029b57/Introduction_to_Machine_Learning.pptx",
  "edit_path": "/presentation?id=d3000f96-096c-4768-b67b-e99aed029b57"
}

Note: Prepend your server’s root URL to path and edit_path to construct valid links.

Documentation & Tutorials

🚀 Roadmap

Track the public roadmap on GitHub Projects: https://github.com/orgs/presenton/projects/2

presenton

Links

README