Run Presenton with Local AI Models for Privacy-First Presentation Generation

AI presentation generation becomes much more practical when you can run it on infrastructure you control. For many teams, privacy, cost predictability, and reliability matter just as much as raw output quality.

That is where Ollama becomes useful. Instead of sending prompts and sensitive business data to external AI providers, you can run capable open-source models locally and connect them directly to Presenton.

If you are looking for a way to generate presentations with AI while keeping everything close to your own environment, this guide will walk you through the full setup.

What exactly is Ollama?

Think of Ollama as Docker for AI models. Instead of making API calls to OpenAI or Anthropic, you download models directly to your machine and run them locally. After the initial download, no internet is required, there are no per-token fees, and your data does not leave your infrastructure.

Ollama handles model management, memory optimization, and hardware usage so that running a model feels much simpler. In practice, it is like having a ChatGPT-style experience running on your own hardware, except it stays under your control.

The best part is that open-source models have improved fast. Many are now strong enough for presentation generation tasks, and some are especially useful when you want a private and customizable AI stack.

Why this matters for presentation generation

Presentation generation often involves sensitive information such as financial data, internal plans, customer details, strategic updates, and competitive analysis. Many organizations prefer to keep this data inside their own environment instead of sending it to third-party services.

Cost is another reason. If you generate presentations regularly, whether for automated reports, internal updates, training materials, or batch workflows, external API costs can add up quickly. Local models shift that tradeoff. You invest in hardware and then generate as much as you need.

Setting up local AI presentations with Presenton

If you are already comfortable with Docker, the setup is straightforward. Presenton can either manage Ollama models automatically for you or connect to an Ollama server that you already run elsewhere.

Basic setup with auto-managed models

This setup allows Presenton to automatically download and manage the specified Ollama model.

docker run -it --name presenton -p 5000:80 \
  -e LLM="ollama" \
  -e OLLAMA_MODEL="llama3.2:3b" \
  -e PEXELS_API_KEY="your_pexels_api_key" \
  -e CAN_CHANGE_KEYS="false" \
  -v "./user_data:/app/user_data" \
  ghcr.io/presenton/presenton:latest

The first run may take a few minutes because the model needs to be downloaded. After that, generation becomes much faster.

Connecting to an existing Ollama server

If you already run Ollama elsewhere, for example on a dedicated GPU server, you can point Presenton to that instance.

docker run -it --name presenton -p 5000:80 \
  -e LLM="ollama" \
  -e OLLAMA_MODEL="llama3.2:3b" \
  -e OLLAMA_URL="http://your-ollama-server:11434" \
  -e PEXELS_API_KEY="your_pexels_api_key" \
  -e CAN_CHANGE_KEYS="false" \
  -v "./user_data:/app/user_data" \
  ghcr.io/presenton/presenton:latest

This works well when multiple applications need to share the same Ollama server or when you want GPU acceleration on a separate machine.

Model selection guide

Different models come with different trade-offs. Some are lightweight and good for testing. Others require far more memory but provide stronger output quality.

One important distinction is graph support. Larger and more capable models are better at generating more structured presentation content, including charts and diagrams. Smaller models are better suited for simpler text-based slides.

GPU acceleration

GPU support can make a major difference, especially when you run larger models. With NVIDIA GPUs, you can add --gpus=all to your Docker command.

docker run -it --name presenton --gpus=all -p 5000:80 \
  -e LLM="ollama" \
  -e OLLAMA_MODEL="llama3.3:70b" \
  -e PEXELS_API_KEY="your_pexels_api_key" \
  -e CAN_CHANGE_KEYS="false" \
  -v "./user_data:/app/user_data" \
  ghcr.io/presenton/presenton:latest

With the right hardware, generation time can drop from minutes to seconds. This is especially helpful in production or when you need to generate larger decks regularly.

Configuration options

Here is what the main environment variables control:

• LLM="ollama" selects Ollama as the AI backend.
• OLLAMA_MODEL="llama3.2:3b" defines which model Presenton should use.
• OLLAMA_URL="http://..." points Presenton to an external Ollama server if needed.
• PEXELS_API_KEY="..." enables automatic stock image integration for better-looking presentations.
• CAN_CHANGE_KEYS="false" locks configuration in production-oriented deployments.

Adding stock images

If you want more polished presentation output, a free Pexels API key can help. It enables automatic stock image integration and gives you a useful free-tier request limit for typical testing and moderate use.

Performance expectations

Performance depends heavily on your hardware. A small model that feels smooth on a laptop may not tell you how a large production model will behave.

• Apple Silicon M1/M2: 3B models run smoothly, 8B models are usable, and 70B models are generally very slow.
• RTX 4080 / 4090: Strong performance even with larger models.
• CPU-only systems: Best paired with 3B or smaller models for reasonable generation speed.
• Dedicated servers: Best option for consistent production performance.

API usage

Once Presenton is running with Ollama, the API usage is the same as a cloud-backed setup. The difference is that all AI processing happens locally.

curl -X POST http://localhost:5000/api/v1/ppt/generate/presentation \
  -F "prompt=Quarterly sales review with growth charts and competitor analysis" \
  -F "n_slides=10" \
  -F "theme=royal_blue" \
  -F "export_as=pptx"

This makes local AI presentation generation appealing when you want privacy without changing the way your applications already interact with Presenton.

Production considerations

If you plan to use local AI presentation generation in production, a few optimizations matter:

• Model persistence: Add -v "./ollama_models:/root/.ollama" so you do not re-download models after container restarts.
• Memory planning: Each model loads fully into RAM or VRAM, so choose models based on your actual hardware.
• Network isolation: After the initial download, your setup can run completely offline.
• Model management: You can change models based on your use case and resource availability.

Common issues and solutions

• Model download fails: Usually caused by connectivity issues or insufficient disk space.
• GPU not detected: Check that NVIDIA Container Toolkit is installed and working properly.
• Out of memory errors: The model is too large for the available RAM or VRAM. Try a smaller one.
• Slow generation: Use GPU acceleration or switch to a lighter model for testing.

Benefits of local AI for presentations

Running Presenton with Ollama offers a strong set of benefits:

• Privacy: Sensitive information stays inside your infrastructure.
• Cost control: No per-token billing after the initial hardware investment.
• Reliability: Less dependency on external API uptime.
• Customization: More control over models and the overall AI pipeline.
• Compliance: Easier alignment with internal governance and data policies.

Expanding your setup

Once the basic setup works, you can start using it in more advanced ways. Local AI presentation generation opens the door to:

• Automated presentation creation from internal data sources
• Organization-specific templates and presentation themes
• Internal presentation APIs for teams and tools
• Multiple Presenton instances for scaling
• Integration with existing business intelligence workflows

Getting started

Local AI presentation generation works especially well for organizations that prioritize privacy, predictable costs, or dependable offline operation. The simplest approach is to start with a small model, validate the workflow, and then move to a larger one if your quality needs increase.

Presenton with Ollama gives developers a practical path to building presentation workflows that stay private, controllable, and production-friendly.