Vadym/obsidian
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
obsidian/01 Projects/presenton/Presenton.md
Vadym Samoilenko affc6a8353 vault backup: 2026-04-29 13:24:32
2026-04-29 13:24:32 +01:00

8.7 KiB
Raw Blame History

name client status tech local_path deploy url tags created server port db
Presenton Oliver Internal active
Node.js
Python
Docker
OpenAI API
Gemini
React
Tailwind CSS
/Users/ai_leed/Documents/Projects/Oliver/presenton docker-compose up
oliver
presentation
ai
open-source
2026-04-14 local 5000 PostgreSQL

Overview

Presenton is an open-source AI presentation generator that creates professional presentations locally on your device using AI models. It serves as an alternative to Gamma, Beautiful AI, and Decktopus, offering users complete control over their data and privacy. The platform supports multiple LLM providers (OpenAI, Google Gemini, Anthropic Claude, Ollama) and image generation sources (DALL-E 3, Gemini Flash, Pexels, Pixabay, ComfyUI), allowing users to generate presentations from prompts, documents, or existing PPTX templates. Key capabilities include custom HTML/Tailwind CSS templates, PPTX/PDF export, MCP server integration, and flexible deployment options.

Tech Stack

  • Frontend: React, Tailwind CSS, HTML5
  • Backend: Node.js, Python
  • Database: PostgreSQL
  • Infrastructure: Docker, Docker Compose (with optional GPU support via NVIDIA)
  • AI/ML: OpenAI API, Google Gemini, Anthropic Claude, Ollama (local models), custom OpenAI-compatible endpoints, ComfyUI
  • Key libraries: Model Context Protocol (MCP), various image generation APIs (DALL-E 3, Gemini Flash, Pexels, Pixabay, NanoBanana)

Architecture

Presenton follows a containerized microservices approach with Docker Compose orchestration:

Core Components:

  1. Frontend UI — React-based web interface for users to input prompts, upload documents/PPTX files, and configure settings
  2. Backend API — Node.js/Python API service that orchestrates presentation generation
  3. LLM Integration Layer — Abstracts multiple LLM providers (OpenAI, Gemini, Claude, Ollama, custom endpoints)
  4. Template Engine — Loads and processes HTML/Tailwind CSS templates; can generate templates from existing PPTX files
  5. Image Generation Layer — Multi-provider image generation (DALL-E 3, Gemini Flash, Pexels, Pixabay, ComfyUI, NanoBanana)
  6. Export Engine — Converts generated presentations to PPTX and PDF formats
  7. MCP Server — Built-in Model Context Protocol server for generating presentations programmatically
  8. Database Layer — PostgreSQL for persistence (user settings, templates, generation history)

Data Flow: User Input (prompt/document/PPTX) → Backend API → LLM Provider → Content Generation → Image Generation → Template Rendering → PPTX/PDF Export → User Download

Deployment Options:

  • Development: docker-compose with Dockerfile.dev (hot reload)
  • Production: docker-compose with Dockerfile (optimized image)
  • GPU-enabled: Production service with NVIDIA GPU reservation
  • API Deployment: Can be hosted as a standalone service for team use
┌─────────────┐
│   Frontend  │ (React/Tailwind)
└──────┬──────┘
       │
       ▼
┌─────────────────────────────────┐
│   Backend API (Node.js/Python)  │
│  ┌──────────────────────────┐   │
│  │  LLM Abstraction Layer   │   │
│  │ (OpenAI/Gemini/Claude)   │   │
│  └──────────────────────────┘   │
│  ┌──────────────────────────┐   │
│  │ Template Engine + Parser │   │
│  └──────────────────────────┘   │
│  ┌──────────────────────────┐   │
│  │ Image Generation Layer   │   │
│  │ (DALL-E/Gemini/etc)      │   │
│  └──────────────────────────┘   │
└──────┬───────────────────────────┘
       │
       ├─► PostgreSQL (persistence)
       │
       └─► PPTX/PDF Export

Dev Commands

# Start development server (with hot reload)
docker-compose up development

# Start production server (CPU)
docker-compose up production

# Start production server (with GPU support)
docker-compose up production-gpu

# Build Docker image
docker build -t presenton:latest .

# Build development image
docker build -f Dockerfile.dev -t presenton:dev .

# View logs
docker-compose logs -f

# Access web interface
# Navigate to http://localhost:5000

Deployment

  • Server: local
  • Deploy: docker-compose up production (or production-gpu for GPU support)
  • URL: http://localhost:5000 (default)
  • Port: 5000 (configurable in docker-compose.yml)
  • Service: Docker Compose managed service
  • Local path: /Users/ai_leed/Documents/Projects/Oliver/presenton
  • Volume mounts: ./app_data:/app_data (persistent data storage)

Deployment Notes:

  • Change port in docker-compose.yml by modifying the port binding (e.g., "8080:80")
  • GPU deployment requires NVIDIA Docker runtime and nvidia-docker
  • Persistent data stored in ./app_data directory
  • Can be deployed on any Docker-capable infrastructure (cloud, on-premise, local)

Environment Variables

Core LLM Configuration:

  • LLM — Primary LLM provider (openai, gemini, claude, ollama, custom)
  • OPENAI_API_KEY — OpenAI API key
  • OPENAI_MODEL — OpenAI model name (e.g., gpt-4-turbo)
  • GOOGLE_API_KEY — Google API key for Gemini
  • GOOGLE_MODEL — Gemini model name
  • ANTHROPIC_API_KEY — Anthropic Claude API key
  • ANTHROPIC_MODEL — Claude model name
  • OLLAMA_URL — Ollama server URL for local models
  • OLLAMA_MODEL — Ollama model name

Custom LLM:

  • CUSTOM_LLM_URL — Custom OpenAI-compatible endpoint URL
  • CUSTOM_LLM_API_KEY — API key for custom endpoint
  • CUSTOM_MODEL — Model name on custom endpoint

Image Generation:

  • PEXELS_API_KEY — Pexels stock image API key
  • COMFYUI_URL — ComfyUI server URL for local image generation
  • COMFYUI_WORKFLOW — ComfyUI workflow configuration

Advanced Features:

  • EXTENDED_REASONING — Enable extended reasoning in LLM
  • TOOL_CALLS — Enable function/tool calling in LLM
  • DISABLE_THINKING — Disable model thinking/reasoning
  • WEB_GROUNDING — Enable web search grounding for content generation
  • DISABLE_ANONYMOUS_TRACKING — Disable anonymous usage telemetry

Infrastructure:

  • DATABASE_URL — PostgreSQL connection string
  • CAN_CHANGE_KEYS — Allow users to change API keys in UI (true/false)

API / Endpoints

Presenton exposes a REST API for presentation generation and includes a built-in MCP (Model Context Protocol) server.

Key API Endpoints (inferred from codebase):

  • POST /api/presentations/generate — Generate presentation from prompt or document
  • POST /api/presentations/template — Generate template from uploaded PPTX
  • POST /api/export — Export presentation to PPTX/PDF
  • GET /api/templates — List available templates
  • POST /api/settings — Update user API key settings
  • GET /health — Health check endpoint

MCP Server Integration:

  • Built-in MCP server for programmatic presentation generation
  • Allows integration with Claude and other MCP-compatible tools

See /docs (https://docs.presenton.ai) for complete API documentation.

Known Issues

  • No explicit issues documented in provided files
  • Icon fallback mechanism in place for missing slide icons (commit d623fa6)
  • Recent API parameter rename from 'prompt' to 'content' (commit c5e36ab)
  • Some MCP/OpenAI spec compatibility fixes implemented (commit 932c807)

Notable Recent Changes:

  • New template system and refactored template loading (v1.0.0+)
  • Added GPT Image 1.5 support
  • NanoBanana image generation integration
  • ComfyUI local image generation workflow support
  • Ukrainian language support added
  • Multiple image provider options (DALL-E 3, Gemini Flash, Pexels, Pixabay)

Git

Sessions

2026-04-14 – Project catalogued

Done: Added to Obsidian second brain.

Change Log

Date Requested Changed Files
2026-04-14 Initial setup Note created —

Related