How AI Presentations Locally with Ollama Work

AI presentations locally with Ollama allow developers to generate editable slide decks without sending presentation content to a hosted language-model provider. By connecting Presenton to Ollama, you can run supported models on your own computer, private server, or GPU infrastructure.

This setup is useful for teams working with internal reports, customer data, financial information, training materials, and confidential business plans. It also gives developers more control over model selection, deployment, performance, and recurring API costs.

In this guide, you will configure Presenton and Ollama in seven steps, connect an existing Ollama endpoint, enable GPU acceleration, generate a presentation through the API, and prepare the workflow for production.

7-step setup overview

1. Install and start Ollama on the host or a dedicated server.
2. Pull a model that fits your available RAM or VRAM.
3. Run Presenton with Docker and persist its application data.
4. Set Ollama as the Presenton language-model provider.
5. Configure the Ollama model and server URL when required.
6. Enable supported GPU access for faster local inference.
7. Test presentation generation through the authenticated API.

What is Ollama AI and how does it work?

Ollama is a local model runtime with a command-line interface and HTTP API for downloading, running, and managing supported models. The official Ollama documentation covers installation, Docker deployment, hardware support, and API usage.

Instead of paying a hosted model provider per token, you run the selected model on your own hardware. After the model is downloaded, local inference can operate without a cloud LLM connection, although your infrastructure, electricity, and any optional external image services still have their own costs and network requirements.

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 Generate Presentations with Local AI Models?

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.

Set Up AI Presentations Locally with Ollama

Setting up AI presentations locally with Ollama requires a compatible Ollama model, a reachable Ollama server, Docker, and a running Presenton instance. The current Presenton deployment exposes the app on port 5001 in the examples below and persists application data in /app_data.

Step 1–4: Run Presenton with Ollama

Start with a smaller model such as llama3.2:3b while validating the workflow. The following command uses the environment-variable names documented by Presenton.

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

Disabling image generation keeps this example focused on the local text-model workflow. You can later configure Pexels, Pixabay, ComfyUI, Open WebUI, or another supported image provider based on your deployment requirements.

Step 5: Connect Presenton to an Existing Ollama Server

When Ollama already runs on the host or on a dedicated inference server, provide its HTTP base URL. From Docker Desktop, host.docker.internal commonly resolves the host machine.

docker run -it --name presenton -p 5001:80 \
  -e LLM="ollama" \
  -e OLLAMA_MODEL="llama3.2:3b" \
  -e OLLAMA_URL="http://host.docker.internal:11434" \
  -e CAN_CHANGE_KEYS="false" \
  -e DISABLE_IMAGE_GENERATION="true" \
  -v "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest

On Linux, Docker host networking and hostname resolution can differ. Use an address that the Presenton container can actually reach, and do not expose an unauthenticated Ollama endpoint publicly.

Choose a Model for AI Presentations Locally with Ollama

The best model for AI presentations locally with Ollama depends on your available RAM, VRAM, generation speed, and required output quality. Some models are lightweight and suitable for testing, while 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 Support for AI Presentations Locally with Ollama

GPU acceleration can make AI presentations locally with Ollama substantially faster, especially with larger models or longer slide decks. For NVIDIA GPUs in Docker, install and configure the NVIDIA Container Toolkit before adding --gpus=all.

docker run -it --name presenton --gpus=all -p 5001:80 \
  -e LLM="ollama" \
  -e OLLAMA_MODEL="llama3.2:3b" \
  -e CAN_CHANGE_KEYS="false" \
  -e DISABLE_IMAGE_GENERATION="true" \
  -v "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest

Review the official Ollama Docker and GPU instructions for current NVIDIA, AMD, and Vulkan configuration details. Actual performance depends on model size, quantization, context length, available memory, and the selected hardware.

Presenton and Ollama 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 the Ollama HTTP API when it is not using the default endpoint.
• START_OLLAMA="true" can be used when the container entrypoint should install and start Ollama; the current default is false in standard compose profiles.
• IMAGE_PROVIDER="pexels" and PEXELS_API_KEY="..." enable optional stock-image search.
• DISABLE_IMAGE_GENERATION="true" prevents external image generation or search when a text-only local workflow is required.
• CAN_CHANGE_KEYS="false" prevents users from changing configured provider keys in the interface.

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.

Local Model Performance and Hardware Requirements

Local performance varies widely. Model file size is only one part of the requirement: the runtime also needs memory for context, temporary buffers, concurrent requests, and the rest of the Presenton application.

• Small models: Better for initial testing, CPU-only machines, and lower-memory systems.
• Mid-sized models: Usually need more RAM or VRAM but can improve instruction following and presentation structure.
• Large models: Require substantial memory and are better suited to dedicated inference hardware.
• Production servers: Should be tested with realistic slide counts, concurrency, and context sizes before launch.

Do not promise a fixed generation time based only on a GPU model. Benchmark the complete workflow on the exact hardware and model configuration you plan to deploy.

API Access for AI Presentations Locally with Ollama

Developers can automate AI presentations locally with Ollama through Presenton’s authenticated presentation API. Once Presenton is running with Ollama, applications can use the same presentation endpoint as other Presenton deployments. Current /api/v1/ routes require HTTP Basic authentication using the Presenton admin credentials.

curl -u username:password \
  -X POST http://localhost:5001/api/v1/ppt/presentation/generate \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Quarterly sales review with growth charts and competitor analysis",
    "n_slides": 10,
    "language": "English",
    "template": "general",
    "export_as": "pptx"
  }'

The response includes a presentation ID, generated file path, and edit path. Use the server’s root URL with the returned paths to create working preview, editing, or download links.

For an interactive way to understand presentation requests before coding the integration, see the internal guide to the Presenton API Playground.

Deploy AI Presentations Locally with Ollama in Production

Before deploying AI presentations locally with Ollama in production, test memory usage, API reliability, presentation quality, concurrent requests, and PPTX and PDF exports. The following deployment checks also matter:

• Data persistence: Persist Presenton data with -v "./app_data:/app_data". Persist Ollama models separately when Ollama runs in its own container.
• Memory planning: Each model loads fully into RAM or VRAM, so choose models based on your actual hardware.
• Network isolation: Local model inference can run offline after model download, but external image providers, web search, and updates still require network access.
• 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 Presentation Generation

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.

How to Scale the Workflow

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

Related Presenton Guides

Before building an integration, review the Presenton API Playground guide to understand presentation-generation requests, authentication, and API responses.

You can also explore more Presenton tutorials and developer guides covering presentation automation, templates, APIs, and deployment.

Start Building Your Local Presentation Workflow

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.

Presenton and Ollama Resources

Use the official Presenton GitHub repository for the latest environment variables, Docker examples, API endpoint details, and deployment changes. Use the Ollama model library to confirm current model tags, download sizes, and context limits.

You can also review more product tutorials on the Presenton blog before moving the workflow into production.