Eigen ChatGPT in 10 minuten: Open WebUI + Ollama (2026)

Open WebUI + Ollama: De 10-Minuten Installatiegids (2026)

Heb je ooit gewild dat ChatGPT op je laptop draaide in plaats van op OpenAI's servers? Open WebUI + Ollama is precies de stack die je zoekt. Open WebUI geeft je de gepolijste chatinterface; Ollama draait de modellen lokaal. Geen API-sleutels, geen kosten per token, geen data die je machine verlaat. Deze gids brengt je in ongeveer tien minuten van een leeg terminal naar je eerste chat — en behandelt daarna de dingen die de meeste tutorials overslaan: spraak I/O, Pipelines, MCP, Apple Silicon benchmarks en een clean HTTPS-pad met Caddy.

Snelle conclusies:

• Open WebUI is een zelf-gehoste, ChatGPT-achtige frontend; Ollama is de lokale modelrunner die het aandrijft.
• Het Docker single-container pad brengt je in ~10 minuten naar je eerste chat op een warme machine.
• Stel OLLAMA_BASE_URL in op http://host.docker.internal:11434 om de "kan geen verbinding maken"-fout negen van de tien keer op te lossen.
• Open WebUI's killer-features zijn Pipelines/Functions, native RAG, spraak I/O en MCP — geen van deze functies biedt LM Studio.

Wat Is Open WebUI + Ollama Eigenlijk?

Open WebUI is een open-source, zelf-gehoste webinterface die Ollama (en andere lokale LLM-runtimes) een ChatGPT-achtige chat UI geeft. Samen laten ze je privé AI-modellen draaien op je eigen machine — geen API-sleutels, geen kosten per token, volledige datacontrole. Open WebUI is de chatlaag; Ollama is de modellaag. Ze communiceren via HTTP op poort 11434, en dat is de volledige architectuur.

Laten we de onderdelen uitsplitsen, want de namen klinken uitwisselbaar maar dat zijn ze niet:

• Open WebUI — de browser-app die je daadwerkelijk gebruikt. Multi-gebruiker, RAG ingebouwd, pluginsysteem, draait op poort 8080 binnen Docker (je mapt het naar 3000 op je host).
• Ollama — de modelserver. Het haalt GGUF-bestanden op (denk aan .mp3 voor AI-modellen), laadt ze op je CPU/GPU en stelt een nette HTTP API beschikbaar op poort 11434.
• Modellen — de werkelijke gewichtsbestanden. llama3.2:3b, qwen2.5:14b, deepseek-r1:7b, enz. Opgehaald via ollama pull, vermeld in Ollama's modelbibliotheek.

Waarom deze combinatie wint: privacy (data blijft lokaal), kosten (nul per token), offline-capable, multi-gebruiker out-of-the-box en een echt plugin-ecosysteem. Als je nieuw bent in dit gebied, behandelt onze gids over lokaal draaien van LLMs de hardwarekant.

De officiële Open WebUI-documentatie is de canonieke referentie — sla hem op als bladwijzer. Hij is beknopt, maar nauwkeurig.

Hoe Installeer Ik Open WebUI met Ollama? (Snelle Setup)

Installeer Docker, installeer Ollama, voer dan docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main uit. Bezoek http://localhost:3000, maak het beheerdersaccount aan, haal een model op via Admin → Instellingen → Verbindingen → Ollama en begin met chatten. Totale tijd: ongeveer 10 minuten op een warme machine.

Hier is het volledige pad, stap voor stap:

1. Docker Desktop installeren — download het van docker.com voor Mac/Windows, of apt install docker.io op Linux.

2. Ollama installeren

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows: installer downloaden van ollama.com

3. Een startmodel ophalen. Ik zou beginnen met llama3.2:3b — snel op bijna alles, slim genoeg om nuttig te zijn. Als je een overzicht wilt van de sterkste opties, bekijk dan onze lijst van beste open-source LLMs.

ollama pull llama3.2:3b

4. De Open WebUI-container uitvoeren (de canonieke opdracht):

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

5. Open http://localhost:3000, registreer je (de eerste gebruiker wordt automatisch beheerder) en je chat.

Pro-tip: Op Apple Silicon Macs, draai Ollama natively (niet in Docker). Dat is by design — het laat Ollama de Metal GPU gebruiken. Open WebUI draait in Docker; de twee communiceren via host.docker.internal:11434.

Over de "10-minuten"-belofte: dat is een warm-machine getal — Docker al geïnstalleerd, fatsoenlijk internet voor de ~2 GB image pull en ~2 GB model pull. Eerste Docker-installatie zonder cache? Tel er tien minuten bij op. Trage verbinding? Tel er nog vijf bij. Eerlijke baseline, geen marketingcijfer.

Docker Compose: De Productieklare Setup

Als je een reproduceerbare, multi-container setup wilt voor Open WebUI plus een zelfstandige Ollama-service, is Docker Compose het schonere pad. Eén YAML-bestand declareert beide services, een gedeeld netwerk, benoemde volumes voor persistentie en laat je herdeployeren met één docker compose up -d. Ideaal voor servers, homelabs of teams.

De truc die mensen struikelt: wanneer beide services binnen Compose draaien, stel OLLAMA_BASE_URL=http://ollama:11434 in (de Compose-servicenaam), niet host.docker.internal. Docker's interne DNS lost de servicenaam automatisch op.

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: always

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui:/app/backend/data
    depends_on:
      - ollama
    restart: always

volumes:
  ollama:
  open-webui:

Start het op:

docker compose up -d
docker compose logs -f

Twee opmerkingen waard. Ten eerste zijn benoemde volumes (ollama: en open-webui: onderaan) beter dan bind mounts hier — Docker beheert permissies en je chatgeschiedenis/configuratie overleeft container-rebuilds. Ten tweede, als je één Open WebUI wilt die praat met lokale Ollama en remote OpenAI/Anthropic via één URL, zet een LiteLLM-proxy ervoor. En als je nog je runtimelaag kiest, behandelt ons overzicht van beste lokale LLM-tools Ollama, vLLM, LM Studio en vrienden.

GPU-Versnelling: NVIDIA, AMD en Apple Silicon

Ollama detecteert NVIDIA GPU's automatisch via de NVIDIA Container Toolkit, AMD GPU's via ROCm op Linux en Apple Silicon GPU's natively via Metal. Je geeft --gpus all niet door aan Open WebUI — alleen Ollama heeft de GPU nodig. De snelste setup op elk platform ziet er anders uit, en sommige "waarom is dit traag"-momenten komen neer op het feit dat Ollama op de verkeerde plek staat.

NVIDIA (Linux + Windows WSL2)

Installeer de NVIDIA Container Toolkit, voer dan Ollama in Docker uit met --gpus all:

docker run -d --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Verifieer met nvidia-smi terwijl een model geladen is — je zou ollama moeten zien in de GPU-proceslijst. De OLLAMA_NUM_GPU omgevingsvariabele laat je lagen beperken wanneer je VRAM deelt met andere workloads.

Apple Silicon (M1/M2/M3/M4)

Draai Ollama natively — niet in Docker. Er is nog geen Metal GPU-passthrough in Docker (begin 2026), dus een ge-dockerde Ollama op Mac valt terug op CPU, en je vraagt je af waarom je M3 Max aanvoelt als een ThinkPad uit 2015. Open WebUI draait nog steeds in Docker; het bereikt Ollama via host.docker.internal:11434.

Op mijn M2 Pro (16 GB) met llama3.2:3b zie ik ongeveer 45-55 tokens/sec. llama3.1:8b zakt naar ~22-28 tokens/sec. qwen2.5:14b is grensgevaarlijk bruikbaar bij ~9-12 tokens/sec — prima voor chat, pijnlijk voor batchwerk. Getallen variëren met kwantisering en contextlengte, maar dat is de orde van grootte.

AMD (ROCm op Linux)

Ollama 0.5+ wordt geleverd met ROCm-ondersteuning voor RDNA2/RDNA3-kaarten (RX 6000/7000-serie, MI200/MI300 datacenterchips). Gebruik de speciale image:

docker run -d --device=/dev/kfd --device=/dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

AMD-prestaties hebben de kloof in 2025 aanzienlijk gedicht — nog niet op NVIDIA-niveau, maar niet langer een wetenschapsproject.

Hoe Voeg Ik RAG (Mijn Eigen PDF's) Toe aan Open WebUI?

Open WebUI heeft native RAG ingebouwd. Klik op je profiel → Workspace → Kennis, maak een kennisbank aan en gooi er PDF's, Word-documenten, Markdown of tekstbestanden in. Op de achtergrond chunkt Open WebUI documenten, embedded ze met het geconfigureerde embeddingmodel (standaard nomic-embed-text), slaat ze op in ChromaDB en haalt ze op bij querytijd. Geen externe service nodig.

Setup vereist één extra stap: haal eerst het embeddingmodel op.

ollama pull nomic-embed-text

Stel daarna in Admin → Instellingen → Documenten het embeddingmodel in op nomic-embed-text. Pas chunkgrootte (standaard 1500) en overlap (standaard 100) naar smaak aan. De klassieke valkuil: te grote chunks overschrijden je contextvenster bij kleine modellen. Als je llama3.2:3b gebruikt met een 4K-context, laten chunks van 1500 tokens bijna geen ruimte voor de werkelijke vraag — zak naar 800 met 80 overlap.

Om een kennisbank in chat te gebruiken, typ # en kies de collectie. Of koppel hem permanent aan een Aangepast Model in Workspace → Modellen. Webzoeken werkt vergelijkbaar — schakel een aanbieder in (SearXNG, Brave of Tavily) in Admin → Instellingen → Webzoeken, en het model kan live resultaten ophalen.

Voor een diepere RAG-vergelijking, zie ons overzicht van RAG-tools. En als ChromaDB op schaal tekortschiet, behandelt ons overzicht van vectordatabase-opties Qdrant, pgvector en de afwegingen.

Spraak I/O: Praten Met Je Lokale AI

Open WebUI ondersteunt zowel spraak-naar-tekst (STT) als tekst-naar-spraak (TTS). Voor STT draait faster-whisper lokaal zonder API-sleutel. Voor TTS kun je OpenAI's TTS API verbinden of een lokale engine draaien zoals coqui-tts. Eenmaal ingeschakeld verschijnt er een microfoonpictogram in de chatbox en begint je lokale AI te antwoorden.

Ga naar Admin → Instellingen → Audio. Twee engines, twee dropdowns.

STT-pad — kies Whisper (Lokaal), kies een modelgrootte: tiny, base, small, medium of large. Het model downloadt automatisch bij eerste gebruik. base is het sweet spot voor de meeste laptops; medium als je GPU-ruimte hebt.

TTS-pad — het eenvoudigst is OpenAI TTS: plak een API-sleutel, kies tts-1 en een stem (alloy, nova, enz.). Volledig lokaal pad: coqui-tts engine, met een apart Docker-image. De meeste mensen kiezen voor lokale Whisper + OpenAI TTS als pragmatisch midden — je audio verlaat de machine nooit voor invoer, en de API-aanroep is slechts een korte tekststring voor uitvoer.

Je kunt de keuze inbakken in de container met omgevingsvariabelen:

docker run -d \
  -e WHISPER_MODEL=base \
  -e AUDIO_STT_ENGINE=whisper \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

De volledige audioreferentie staat in de Open WebUI GitHub-documentatie.

Pipelines & Functions: Open WebUI's Killer-Feature

Pipelines en Functions zijn de manier om Open WebUI uit te breiden zonder het te forken. Pipelines zijn externe Python-services die fungeren als filters, modelrouters of volledige aangepaste handlers. Functions zijn inline Python (Filter, Action of Pipe) die binnen Open WebUI zelf leven. Samen zijn ze de reden waarom Open WebUI LM Studio verslaat voor serieuze gebruikers.

Drie Function-typen, één zin elk:

• Filter — voor-/naverwerkt berichten (PII-verwijdering, grof taalfilter, prompt-herschrijving).
• Action — een knop in de chat UI die Python triggert (opnieuw samenvatten, opslaan in Notion, SQL-query uitvoeren).
• Pipe — een volledige aangepaste modelhandler (routeren naar een remote API, meerdere modellen koppelen, een agent bouwen).

Hier is een minimale Filter die e-mailadressen uit gebruikers-prompts verwijdert voordat ze het model bereiken:

from pydantic import BaseModel
import re

class Filter:
    class Valves(BaseModel):
        priority: int = 0

    def __init__(self):
        self.valves = self.Valves()

    def inlet(self, body: dict, __user__: dict = None) -> dict:
        for message in body.get("messages", []):
            if message.get("role") == "user":
                message["content"] = re.sub(
                    r"[\w\.-]+@[\w\.-]+",
                    "[REDACTED_EMAIL]",
                    message["content"],
                )
        return body

Gooi dat in Admin → Instellingen → Functions → Nieuw, sla op en schakel het in voor elk model. Klaar.

Voor externe Pipelines, start de speciale container naast Open WebUI:

  pipelines:
    image: ghcr.io/open-webui/pipelines:main
    container_name: pipelines
    ports:
      - "9099:9099"
    volumes:
      - pipelines:/app/pipelines
    restart: always

Voeg dan in Admin → Instellingen → Verbindingen http://pipelines:9099 toe als OpenAI-compatibele API. Upload .py-bestanden in Admin → Instellingen → Pipelines. De officiële Pipelines-repo heeft tientallen voorbeelden — vertaalrouters, Langfuse-logging, function calling, en meer.

MCP: Open WebUI Verbinden met Externe Tools

Open WebUI 0.6+ ondersteunt het Model Context Protocol (MCP), wat betekent dat je lokale model externe tools kan aanroepen — bestandszoeken, GitHub, Slack, je eigen aangepaste servers — via hetzelfde protocol dat Claude Desktop gebruikt. Het is de schoonste manier om een lokaal model echt toolgebruik te geven zonder een Pipeline te schrijven.

Voeg een MCP-server toe in Admin → Instellingen → Tools: plak de server URL, geef hem een naam en schakel per model in. Het model beslist wanneer het hem aanroept tijdens de chat. We behandelen het protocol van begin tot eind in onze Model Context Protocol (MCP) gids — dezelfde patronen, alleen vanuit de Open WebUI-kant in plaats van Claude Desktop's kant.

Waarom dit belangrijk is: halverwege 2026 noemt bijna geen Open WebUI-tutorial MCP. Als je al gestandaardiseerd bent op MCP-servers voor je Claude- of Cursor-setup, kun je Open WebUI naar exact dezelfde servers wijzen. Eén protocol, elke client.

Waarom Ziet Open WebUI Mijn Ollama-Modellen Niet? (Probleemoplossing)

Als Open WebUI laadt maar de modeldropdown leeg is, kan de container Ollama niet bereiken. Negen van de tien keer is de oplossing --add-host=host.docker.internal:host-gateway plus OLLAMA_BASE_URL=http://host.docker.internal:11434. Op Linux zonder de host-gateway vlag kan Docker's bridge-netwerk poort 11434 van de host niet zien. De eerste keer dat we dit op een Linux-machine van een klant deployden, hadden we precies dit probleem en verloren we een uur.

Drie oorzaken, in volgorde van frequentie:

1. Ontbrekende --add-host vlag (meest voorkomend op Linux). macOS Docker Desktop stelt host.docker.internal automatisch in; Linux heeft de expliciete vlag nodig.

2. Ollama alleen gebonden aan 127.0.0.1. Vanuit het perspectief van de container is dat niet bereikbaar. Oplossing:

   bash

   OLLAMA_HOST=0.0.0.0:11434 ollama serve

   Of stel Environment="OLLAMA_HOST=0.0.0.0:11434" in in de systemd-unit op Linux.

3. Firewall / antivirus blokkeert 11434. Minder gebruikelijk, maar controleer ufw, Windows Defender of bedrijfseindpuntbeveiliging.

Diagnose — voer dit uit vanuit de Open WebUI-container:

docker exec open-webui curl http://host.docker.internal:11434/api/tags

Als dat JSON retourneert met je modellijst, is het netwerk goed en ligt het probleem in Open WebUI's instellingen (controleer Admin → Verbindingen → Ollama URL). Als het hangt of weigert, heb je een host-side probleem — begin met oorzaak #2.

Open WebUI vs LM Studio vs Jan vs AnythingLLM

Open WebUI wint op multi-gebruiker, RAG-diepte en Pipelines/Functions. LM Studio wint op out-of-the-box GPU-prestaties en een gepolijste single-user UI. Jan wint op minimale wrijving bij eerste start. AnythingLLM wint op ergonomie van documentingestie. Als je een zelf-gehoste ChatGPT-vervanger voor een team wilt, is Open WebUI het antwoord.

Conclusie: als je een solo-ontwikkelaar bent die gewoon een model op je gaming GPU wil draaien en chatten, is LM Studio sneller in te stellen. Als je een privé ChatGPT voor een team bouwt, serieuze RAG doet of aangepaste Python-logica verdraadt, is Open WebUI de enige echte keuze. Ons bredere artikel over beste lokale LLM-tools vergelijkt de runtimelaag (vLLM, llama.cpp, Ollama) onder deze UI's.

Hoe Stel Ik Open WebUI Veilig Beschikbaar via HTTPS?

Twee schone paden: een 5-regelig Caddyfile voor Open WebUI voor een echt Let's Encrypt-certificaat (productie-achtig), of een Cloudflare Tunnel voor team-gebruik zonder open poorten. Beide houden Open WebUI op localhost:3000 terwijl ze een schone publieke URL met HTTPS blootstellen. Kies op basis van of je DNS voor een domein beheert.

Het Caddy-pad — wijs je domein naar de machine, dan:

ai.example.com {
    reverse_proxy localhost:3000
}

Dat is de volledige configuratie. Caddy haalt automatisch een Let's Encrypt-certificaat op bij het eerste verzoek. Voer caddy run --config Caddyfile uit (of gebruik de systemd-unit). Volledige referentie: Caddy-documentatie.

Het Cloudflare Tunnel-pad — cloudflared tunnel create open-webui, route een hostnaam in je Cloudflare-zone, dan cloudflared tunnel run. Geen open poorten, Cloudflare handelt TLS af. Ideaal voor "ik wil dat mijn team hier toegang toe heeft zonder gaten in mijn firewall te prikken."

Één harde regel: stel poort 3000 nooit rauw bloot aan het publieke internet. Open WebUI's registratie is standaard open — iedereen die je URL raakt, kan een account aanmaken. WEBUI_AUTH=False is prima voor LAN, nooit voor publiek gebruik. Zet altijd een reverse proxy plus geauthenticeerde registratie-whitelisting ervoor (Admin → Instellingen → Algemeen → "Inschrijving inschakelen" uitschakelen nadat je je accounts hebt aangemaakt).

Hoe Techsy Lokale LLM-Implementaties Aanpakt

We hebben Open WebUI + Ollama-setups geleverd voor klanten in juridische dienstverlening, zorg en interne tooling-teams die geen data naar OpenAI kunnen (of willen) sturen. De patronen herhalen zich genoeg dat we ze niet meer van scratch schrijven — maar elke implementatie heeft dezelfde drie prioriteiten.

Wat we daadwerkelijk doen:

• Het model afstemmen op hardware en budget. Het 3B–8B-bereik treft het sweet spot vaker dan niet. Groter is niet altijd beter wanneer latentie en maandelijkse kosten tellen.
• De implementatie hardenen. Caddy ervoor, registratie uitgeschakeld, /app/backend/data op een back-upvolume, wekelijkse snapshots en een daadwerkelijk disaster recovery-plan.
• Pipelines bekabelen voor organisatiespecifieke behoeften. PII-verwijderingsfilters, aangepaste RAG-pipelines gericht op interne SharePoint of Confluence, function-calling tools voor veilige shell-toegang — de dingen die een chat UI daadwerkelijk nuttig maken binnen een bedrijf.

Als je liever de setup overslaat en een draaiende privé AI-stack aangeleverd wilt krijgen, boek dan een gratis consult. We bespreken graag de scope.

Samenvatting

Drie snelle recaps:

• Single-container pad — snelste weg naar eerste chat, tien eerlijke minuten op een warme machine.
• Docker Compose — wat je eigenlijk wilt voor alles wat een herstart moet overleven.
• Pipelines + RAG + MCP — de slotgracht die Open WebUI de moeite waard maakt boven LM Studio of Jan.

Je chat in tien minuten met je eigen AI. Daarna is alles incrementeel — voeg RAG toe als je documenten hebt, voeg Caddy toe als je het op je telefoon wilt, voeg Pipelines toe als je het echt werk wilt laten doen. Als je dieper wilt ingaan op lokale modelselectie, behandelt onze gids over lokaal draaien van LLMs de hardwarekant uitgebreid.

FAQ

Hoe installeer ik Open WebUI met Ollama?

Drie stappen: installeer Docker Desktop, installeer Ollama (curl -fsSL https://ollama.com/install.sh | sh op macOS/Linux), voer dan de canonieke Open WebUI-container uit met docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main. Open http://localhost:3000 en maak je beheerdersaccount aan.

Is Open WebUI gratis?

Ja — Open WebUI heeft een MIT-licentie en is volledig open-source. Zelf-hosten is gratis; je betaalt alleen voor de hardware die het draait (je laptop, een homelab-server of een cloud-VM). Optionele betaalde onderdelen zijn onder meer OpenAI's TTS API voor spraak of commerciële modellen die toegankelijk zijn via Open WebUI's OpenAI-compatibele connector. Alles wat kern is, is gratis.

Kan Open WebUI zonder Ollama werken?

Ja — Open WebUI praat met elke OpenAI-compatibele API. Je kunt het rechtstreeks op OpenAI wijzen, Anthropic via een LiteLLM-proxy, vLLM-servers, de HTTP-server van llama.cpp of gehoste aanbieders zoals Groq en Together. Maar "Open WebUI + Ollama" is de canonieke lokale AI-combinatie omdat Ollama modelbeheer kinderlijk eenvoudig maakt.

Waarom kan Open WebUI geen verbinding maken met Ollama?

Meest voorkomende oorzaak: ontbrekende --add-host=host.docker.internal:host-gateway vlag en OLLAMA_BASE_URL niet ingesteld in Open WebUI's instellingen. Op een na meest voorkomend: Ollama alleen gebonden aan 127.0.0.1, onbereikbaar vanuit de container — los op met OLLAMA_HOST=0.0.0.0:11434 ollama serve. Voer docker exec open-webui curl http://host.docker.internal:11434/api/tags uit voor snelle diagnose.

Hoe voeg ik modellen toe aan Open WebUI?

Eenvoudigste pad: voer vanaf de host ollama pull llama3.2:3b uit (of een model van ollama.com/library). Het model verschijnt automatisch in Open WebUI's dropdown — geen herstart nodig. Als alternatief, ga in Open WebUI naar Admin → Instellingen → Verbindingen → Ollama en gebruik de in-UI pull-knop. In elk geval leven de modellen aan de Ollama-kant.

Wat is het verschil tussen Open WebUI en LM Studio?

LM Studio is een single-user desktop app gericht op modelbeheer plus chat — sterke GPU-standaardinstellingen, strakke UI, geen multi-gebruiker. Open WebUI is een zelf-gehoste server die meerdere gebruikers, native RAG, spraak I/O, Pipelines/Functions en MCP ondersteunt. Verschillende doelgroepen: LM Studio voor solo desktop power users, Open WebUI voor teams of iedereen die een uitbreidbare privé ChatGPT wil.

Kan ik Open WebUI op een telefoon gebruiken?

Ja — Open WebUI is volledig responsief, dus elke mobiele browser werkt. Combineer het met HTTPS (Caddy met een Let's Encrypt-certificaat of een Cloudflare Tunnel) en het wordt een volledig functionele mobiele chat-app. Voeg het toe aan je startscherm op iOS of Android voor een bijna-native PWA-ervaring. Stel het niet publiek beschikbaar zonder authenticatie.

Hoe update ik Open WebUI?

Haal de nieuwste image op en herstart: docker pull ghcr.io/open-webui/open-webui:main && docker stop open-webui && docker rm open-webui en voer dan je originele docker run-opdracht opnieuw uit. Benoemde volumes bewaren alle data — chatgeschiedenis, gebruikers, RAG-collecties en instellingen. Met Docker Compose: docker compose pull && docker compose up -d. Updates verschijnen ongeveer wekelijks.

Ondersteunt Open WebUI spraakchat?

Ja — zowel spraak-naar-tekst (via lokale faster-whisper) als tekst-naar-spraak (via OpenAI's TTS API of lokale coqui-tts). Configureer beide in Admin → Instellingen → Audio. Eenmaal ingeschakeld verschijnt er een microfoonpictogram in de chatbox. De pragmatische setup is lokale Whisper plus OpenAI TTS — volledig offline invoer, snelle schone uitvoer. Zie de sectie Spraak I/O hierboven voor omgevingsvariabelen-configuratie.

Hoe voeg ik mijn PDF's toe aan Open WebUI?

Klik op je profiel → Workspace → Kennis → Nieuwe collectie, upload dan PDF's, Word-documenten, Markdown of tekstbestanden. Open WebUI chunkt de documenten, embedded ze met nomic-embed-text (haal het eerst op via ollama pull nomic-embed-text) en slaat ze op in ChromaDB. Verwijs naar een collectie in chat met #collectienaam of koppel het permanent aan een Aangepast Model.