Lokal ChatGPT på 10 Minuter: Open WebUI + Ollama (2026)

Open WebUI + Ollama: Installationsguiden på 10 Minuter (2026)

Har du någonsin önskat att ChatGPT körde på din dator istället för på OpenAIs servrar? Open WebUI + Ollama är precis den stack du vill ha. Open WebUI ger dig det polerade chattgränssnittet; Ollama kör modellerna lokalt. Inga API-nycklar, ingen fakturering per token, ingen data som lämnar din maskin. Den här guiden tar dig från en tom terminal till ditt första samtal på ungefär tio minuter — och täcker sedan det som de flesta handledningar hoppar över: röst I/O, Pipelines, MCP, Apple Silicon-riktmärken och en ren HTTPS-väg med Caddy.

Snabba slutsatser:

• Open WebUI är ett självhostat ChatGPT-liknande frontend; Ollama är den lokala modellköraren som driver det.
• Docker single-container-vägen tar dig till det första samtalet på ~10 minuter på en varm maskin.
• Ställ in OLLAMA_BASE_URL till http://host.docker.internal:11434 för att lösa felet "kan inte ansluta" nio gånger av tio.
• Open WebUIs mördarfunktioner är Pipelines/Functions, native RAG, röst I/O och MCP — ingen av dessa har LM Studio.

Vad Är Egentligen Open WebUI + Ollama?

Open WebUI är ett öppen källkods, självhostat webbgränssnitt som ger Ollama (och andra lokala LLM-runtimes) ett ChatGPT-liknande chatttgränssnitt. Tillsammans låter de dig köra privata AI-modeller på din egen maskin — inga API-nycklar, ingen kostnad per token, full datakontroll. Open WebUI är chattlagret; Ollama är modelllagret. De kommunicerar via HTTP på port 11434, och det är hela arkitekturen.

Låt oss bryta ner delarna, för namnen låter utbytbara men är det inte:

• Open WebUI — webbläsarappen du faktiskt använder. Flersanvändare, RAG inbyggt, pluginsystem, körs på port 8080 inuti Docker (du mappar det till 3000 på din värd).
• Ollama — modellservern. Den hämtar GGUF-filer (tänk .mp3 för AI-modeller), laddar dem på din CPU/GPU och exponerar ett snyggt HTTP-API på port 11434.
• Modeller — faktiska viktfiler. llama3.2:3b, qwen2.5:14b, deepseek-r1:7b osv. Hämtas via ollama pull, listade i Ollamas modellbibliotek.

Varför den här kombinationen vinner: integritet (data stannar lokalt), kostnad (noll per token), offline-kapabel, flersanvändare direkt från start och ett verkligt plugin-ekosystem. Om du är ny i det här utrymmet täcker vår guide om att köra LLMs lokalt hårdvarusidan.

Den officiella Open WebUI-dokumentationen är den kanoniska referensen — bokmärk den. Den är kortfattad, men noggrann.

Hur Installerar Jag Open WebUI med Ollama? (Snabbinstallation)

Installera Docker, installera Ollama, kör sedan 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. Besök http://localhost:3000, skapa administratörskontot, hämta en modell från Admin → Inställningar → Anslutningar → Ollama och börja chatta. Total tid: ungefär 10 minuter på en varm maskin.

Här är den fullständiga vägen, steg för steg:

1. Installera Docker Desktop — ladda ner det från docker.com för Mac/Windows, eller apt install docker.io på Linux.

2. Installera Ollama

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

# Windows: ladda ner installationsprogrammet från ollama.com

3. Hämta en startmodell. Jag skulle börja med llama3.2:3b — snabb på nästan allt, smart nog för att vara användbar. Om du vill ha en genomgång av de starkaste alternativen, kolla vår lista över bästa open source-LLMs.

ollama pull llama3.2:3b

4. Kör Open WebUI-containern (det kanoniska kommandot):

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. Öppna http://localhost:3000, registrera dig (den första användaren blir automatiskt administratör) och du chattar.

Proffstips: På Apple Silicon-Macs, kör Ollama nativt (inte i Docker). Det är av design — det låter Ollama använda Metal GPU. Open WebUI kör i Docker; de två kommunicerar via host.docker.internal:11434.

Om "10-minuters"-löftet: det är ett varmt maskin-nummer — Docker redan installerat, anständigt internet för ~2 GB bild-hämtning och ~2 GB modell-hämtning. Första Docker-installation utan cache? Lägg till tio minuter. Långsam anslutning? Lägg till ytterligare fem. Ärlig baslinje, inte ett marknadsföringsnummer.

Docker Compose: Den Produktionsklara Konfigurationen

Om du vill ha en reproducerbar, flercontainer-konfiguration för Open WebUI plus en fristående Ollama-tjänst är Docker Compose den renare vägen. En YAML-fil deklarerar båda tjänsterna, ett delat nätverk, namngivna volymer för persistens och låter dig omdistribuera med ett enda docker compose up -d. Utmärkt för servrar, homelabs eller team.

Tricket som snubblar folk: när båda tjänsterna kör inuti Compose, ställ in OLLAMA_BASE_URL=http://ollama:11434 (Compose-tjänstnamnet), inte host.docker.internal. Dockers interna DNS löser tjänstnamnet automatiskt.

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:

Starta det:

docker compose up -d
docker compose logs -f

Två anteckningar värda att lyfta fram. Först slår namngivna volymer (ollama: och open-webui: längst ner) bind mounts här — Docker hanterar behörigheter och din chatthistorik/konfiguration överlever container-återuppbyggnader. Andra, om du vill att ett Open WebUI ska prata med lokal Ollama och fjärr-OpenAI/Anthropic via en enda URL, lägg en LiteLLM-proxy framför. Och om du fortfarande väljer ditt runtime-lager täcker vår genomgång av bästa lokala LLM-verktyg Ollama, vLLM, LM Studio och vänner.

GPU-Acceleration: NVIDIA, AMD och Apple Silicon

Ollama detekterar automatiskt NVIDIA GPU:er via NVIDIA Container Toolkit, AMD GPU:er via ROCm på Linux och Apple Silicon GPU:er nativt via Metal. Du skickar inte --gpus all till Open WebUI — bara Ollama behöver GPU:n. Den snabbaste konfigurationen på varje plattform ser annorlunda ut, och vissa "varför är det här långsamt"-stunder handlar om att Ollama är på fel plats.

NVIDIA (Linux + Windows WSL2)

Installera NVIDIA Container Toolkit, kör sedan Ollama i Docker med --gpus all:

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

Verifiera med nvidia-smi medan en modell är laddad — du bör se ollama i GPU-processlistan. Miljövariabeln OLLAMA_NUM_GPU låter dig begränsa lager när du delar VRAM med andra arbetsbelastningar.

Apple Silicon (M1/M2/M3/M4)

Kör Ollama nativt — inte i Docker. Det finns ingen Metal GPU-genomströmning till Docker ännu (tidigt 2026), så en dockeriserad Ollama på Mac faller tillbaka till CPU, och du undrar varför din M3 Max känns som en ThinkPad från 2015. Open WebUI kör fortfarande i Docker; det når Ollama via host.docker.internal:11434.

På min M2 Pro (16 GB) med llama3.2:3b ser jag ungefär 45-55 tokens/sek. llama3.1:8b sjunker till ~22-28 tokens/sek. qwen2.5:14b är marginellt användbar vid ~9-12 tokens/sek — okej för chatt, smärtsamt för batcharbete. Siffrorna varierar med kvantisering och kontextlängd, men det är storleksordningen.

AMD (ROCm på Linux)

Ollama 0.5+ levereras med ROCm-stöd för RDNA2/RDNA3-kort (RX 6000/7000-serien, MI200/MI300 datacenterchips). Använd den dedikerade bilden:

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

AMD-prestandan har stängt gapet meningsfullt under 2025 — inte NVIDIA-nivå ännu, men inte längre ett vetenskapsprojekt.

Hur Lägger Jag Till RAG (Mina Egna PDF:er) i Open WebUI?

Open WebUI levereras med inbyggd RAG. Klicka på din profil → Workspace → Kunskap, skapa en kunskapsbas och lägg i PDF:er, Word-dokument, Markdown eller textfiler. Bakom kulisserna delar Open WebUI upp dokument i bitar, bäddar in dem med den konfigurerade inbäddningsmodellen (standard nomic-embed-text), lagrar dem i ChromaDB och hämtar vid frågetid. Ingen extern tjänst krävs.

Konfigurationen kräver ett extra steg: hämta inbäddningsmodellen först.

ollama pull nomic-embed-text

Sedan i Admin → Inställningar → Dokument, ställ in inbäddningsmodellen till nomic-embed-text. Justera chunkstorlek (standard 1500) och överlappning (standard 100) efter smak. Det klassiska misstaget: för stora bitar spräcker ditt kontextfönster på små modeller. Om du kör llama3.2:3b med en 4K-kontext lämnar bitar på 1500 tokens nästan inget utrymme för den faktiska frågan — sänk till 800 med 80 överlappning.

För att använda en kunskapsbas i chatten, skriv # och välj samlingen. Eller bifoga den permanent till en Anpassad Modell i Workspace → Modeller. Webbsökning fungerar på liknande sätt — aktivera en leverantör (SearXNG, Brave eller Tavily) i Admin → Inställningar → Webbsökning, och modellen kan hämta direkta resultat.

För en djupare RAG-jämförelse, se vår genomgång av RAG-verktyg. Och om ChromaDB inte räcker vid skala täcker vår genomgång av vektordatabasalternativ Qdrant, pgvector och avvägningarna.

Röst I/O: Prata Med Din Lokala AI

Open WebUI stöder både tal-till-text (STT) och text-till-tal (TTS). För STT kör faster-whisper lokalt utan API-nyckel. För TTS kan du koppla OpenAIs TTS API eller köra en lokal motor som coqui-tts. När det är aktiverat visas en mikrofonikon i chattrutan och din lokala AI börjar svara.

Gå till Admin → Inställningar → Ljud. Två motorer, två rullgardinsmenyer.

STT-väg — välj Whisper (Lokal), välj en modellstorlek: tiny, base, small, medium eller large. Modellen laddas ner automatiskt vid första användningen. base är den optimala punkten för de flesta laptops; medium om du har GPU-utrymme.

TTS-väg — enklast är OpenAI TTS: klistra in en API-nyckel, välj tts-1 och en röst (alloy, nova osv.). Helt lokal väg: coqui-tts-motor, med en separat Docker-bild. De flesta landar på lokal Whisper + OpenAI TTS som ett pragmatiskt mellanting — ditt ljud lämnar aldrig datorn för indata, och API-anropet är bara en kort textsträng för utdata.

Du kan baka in valet i containern med miljövariabler:

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

Den fullständiga ljudreferensen finns i Open WebUI GitHub-dokumentationen.

Pipelines & Functions: Open WebUIs Mördarfunktion

Pipelines och Functions är hur du utökar Open WebUI utan att forka det. Pipelines är externa Python-tjänster som fungerar som filter, modellroutrar eller fullständiga anpassade hanterare. Functions är inline-Python (Filter, Action eller Pipe) som lever inuti Open WebUI självt. Tillsammans är de anledningen till att Open WebUI slår LM Studio för seriösa användare.

Tre Function-typer, en mening vardera:

• Filter — för-/efterbearbetar meddelanden (PII-redigering, svordomar-filter, prompt-omskrivning).
• Action — en knapp i chattgränssnittet som utlöser Python (sammanfatta igen, spara i Notion, kör en SQL-fråga).
• Pipe — en fullständig anpassad modellhanterare (dirigera till ett fjärr-API, koppla flera modeller, bygg en agent).

Här är ett minimalt Filter som tar bort e-postadresser från användarprompter innan de når modellen:

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

Lägg det i Admin → Inställningar → Functions → Nytt, spara och aktivera det för vilken modell som helst. Klart.

För externa Pipelines, starta den dedikerade containern bredvid Open WebUI:

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

Sedan i Admin → Inställningar → Anslutningar, lägg till http://pipelines:9099 som ett OpenAI-kompatibelt API. Ladda upp .py-filer i Admin → Inställningar → Pipelines. Det officiella Pipelines-repot har dussintals exempel — översättningsroutrar, Langfuse-loggning, funktionsanrop och mer.

MCP: Ansluta Open WebUI till Externa Verktyg

Open WebUI 0.6+ stöder Model Context Protocol (MCP), vilket innebär att din lokala modell kan anropa externa verktyg — filsökning, GitHub, Slack, dina egna anpassade servrar — via samma protokoll som Claude Desktop använder. Det är det renaste sättet att ge en lokal modell verklig verktygsanvändning utan att skriva en Pipeline.

Lägg till en MCP-server i Admin → Inställningar → Verktyg: klistra in server-URL:en, ge den ett namn och aktivera per modell. Modellen bestämmer när den ska anropa den under chatten. Vi täcker protokollet från slut till slut i vår guide till Model Context Protocol (MCP) — samma mönster, bara från Open WebUI-sidan istället för Claude Desktops.

Varför det spelar roll: från mitten av 2026 nämner nästan ingen Open WebUI-handledning MCP. Om du redan har standardiserat på MCP-servrar för din Claude- eller Cursor-konfiguration kan du peka Open WebUI på exakt samma servrar. Ett protokoll, varje klient.

Varför Kan Open WebUI Inte Se Mina Ollama-Modeller? (Felsökning)

Om Open WebUI laddas men modell-rullgardinsmenyn är tom kan containern inte nå Ollama. Nio gånger av tio är lösningen --add-host=host.docker.internal:host-gateway plus OLLAMA_BASE_URL=http://host.docker.internal:11434. På Linux utan host-gateway-flaggan kan Dockers bryggnätverk inte se värdens port 11434. Första gången vi driftsatte detta på en klients Linux-dator stötte vi på precis detta och förlorade en timme.

Tre grundorsaker, i frekvensordning:

1. Saknad --add-host-flagga (vanligast på Linux). macOS Docker Desktop ställer in host.docker.internal automatiskt; Linux behöver den explicita flaggan.

2. Ollama bunden till enbart 127.0.0.1. Ur containerns perspektiv är det inte nåbart. Lösning:

   bash

   OLLAMA_HOST=0.0.0.0:11434 ollama serve

   Eller ställ in Environment="OLLAMA_HOST=0.0.0.0:11434" i systemd-enheten på Linux.

3. Brandvägg / antivirusprogram som blockerar 11434. Mindre vanligt, men kontrollera ufw, Windows Defender eller företagets slutpunktsskydd.

Diagnostik — kör detta inifrån Open WebUI-containern:

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

Om det returnerar JSON med din modelllista är nätverket okej och problemet finns i Open WebUI:s inställningar (kontrollera Admin → Anslutningar → Ollama URL). Om det hänger eller vägrar har du ett värdproblem — börja med orsak #2.

Open WebUI vs LM Studio vs Jan vs AnythingLLM

Open WebUI vinner på fleranvändare, RAG-djup och Pipelines/Functions. LM Studio vinner på out-of-the-box GPU-prestanda och ett polerat single-user-gränssnitt. Jan vinner på minimal friktion vid första körning. AnythingLLM vinner på dokumentinmatningsergonomi. Om du vill ha en självhostad ChatGPT-ersättare för ett team är Open WebUI svaret.

Slutsats: om du är en soloutvecklare som bara vill köra en modell på ditt gaming-GPU och chatta är LM Studio snabbare att konfigurera. Om du bygger en privat ChatGPT för ett team, gör seriös RAG eller kopplar anpassad Python-logik är Open WebUI det enda riktiga valet. Vår bredare artikel om bästa lokala LLM-verktyg jämför runtime-lagret (vLLM, llama.cpp, Ollama) under dessa gränssnitt.

Hur Exponerar Jag Open WebUI Säkert via HTTPS?

Två rena vägar: en 5-raders Caddyfile framför Open WebUI för ett riktigt Let's Encrypt-certifikat (nästan produktions-klart), eller en Cloudflare Tunnel för team-användning utan öppna portar. Båda håller Open WebUI på localhost:3000 medan de exponerar en ren publik URL med HTTPS. Välj baserat på om du kontrollerar DNS för en domän.

Caddy-vägen — peka din domän på datorn, sedan:

ai.example.com {
    reverse_proxy localhost:3000
}

Det är hela konfigurationen. Caddy hämtar automatiskt ett Let's Encrypt-certifikat vid den första begäran. Kör caddy run --config Caddyfile (eller använd systemd-enheten). Fullständig referens: Caddy-dokumentation.

Cloudflare Tunnel-vägen — cloudflared tunnel create open-webui, dirigera ett värdnamn i din Cloudflare-zon, sedan cloudflared tunnel run. Noll öppna portar, Cloudflare hanterar TLS. Utmärkt för "jag vill att mitt team är på detta utan att borra hål i min brandvägg."

En hård regel: aldrig exponera port 3000 rå till det offentliga internet. Open WebUIs registrering är öppen som standard — vem som helst som träffar din URL kan skapa ett konto. WEBUI_AUTH=False är okej för LAN, aldrig för offentlig användning. Sätt alltid en omvänd proxy plus autentiserad registrerings-whitelist framför (Admin → Inställningar → Allmänt → "Aktivera registrering" av efter att du har skapat dina konton).

Hur Techsy Hanterar Lokala LLM-Driftsättningar

Vi har levererat Open WebUI + Ollama-konfigurationer för kunder inom juridik, hälso- och sjukvård och interna verktygs-team som inte kan (eller vill) skicka data till OpenAI. Mönstren upprepas tillräckligt för att vi har slutat skriva dem från grunden — men varje driftsättning har samma tre prioriteringar.

Vad vi faktiskt gör:

• Rätt-storleka modellen till hårdvaran och budgeten. Intervallet 3B–8B träffar den söta punkten mer ofta än inte. Större är inte alltid bättre när latens och månadskostnad spelar roll.
• Härda driftsättningen. Caddy framför, registrering inaktiverad, /app/backend/data på en säkerhetskopierad namngiven volym, veckovisa ögonblicksbilder och en faktisk katastrofåterställningsplan.
• Koppla Pipelines för organisationsspecifika behov. PII-redigeringsfilter, anpassade RAG-pipelines pekade på intern SharePoint eller Confluence, funktionsanrops-verktyg för säker shell-åtkomst — det som gör ett chattgränssnitt faktiskt användbart inuti ett företag.

Om du hellre vill hoppa över installationen och få en körande privat AI-stack överlämnad, boka en gratis konsultation. Vi hjälper gärna till att fastställa omfattningen.

Sammanfattning

Tre snabba sammanfattningar:

• Single-container-vägen — snabbaste sättet till det första samtalet, tio ärliga minuter på en varm maskin.
• Docker Compose — vad du faktiskt vill ha för allt som behöver överleva en omstart.
• Pipelines + RAG + MCP — vallgraven som gör Open WebUI värt att välja över LM Studio eller Jan.

Du chattar med din egen AI på tio minuter. Därifrån är det allt inkrementellt — lägg till RAG när du har dokument, lägg till Caddy när du vill ha det på din telefon, lägg till Pipelines när du vill att det ska göra riktigt arbete. Om du vill gå djupare in i lokalt modellval täcker vår guide om att köra LLMs lokalt hårdvarusidan på djupet.

Vanliga Frågor

Hur installerar jag Open WebUI med Ollama?

Tre steg: installera Docker Desktop, installera Ollama (curl -fsSL https://ollama.com/install.sh | sh på macOS/Linux), kör sedan den kanoniska Open WebUI-containern med 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. Öppna http://localhost:3000 och skapa ditt administratörskonto.

Är Open WebUI gratis?

Ja — Open WebUI är MIT-licensierat och helt öppen källkod. Självhosting är gratis; du betalar bara för hårdvaran som kör det (din laptop, en homelab-server eller en molnbaserad VM). Valfria betalda delar inkluderar OpenAIs TTS API för röst eller kommersiella modeller som nås via Open WebUIs OpenAI-kompatibla anslutare. Allt kärnfunktionellt är kostnadsfritt.

Kan Open WebUI köras utan Ollama?

Ja — Open WebUI pratar med vilket OpenAI-kompatibelt API som helst. Du kan peka det direkt mot OpenAI, Anthropic via en LiteLLM-proxy, vLLM-servrar, llama.cpp:s HTTP-server eller hostade leverantörer som Groq och Together. Men "Open WebUI + Ollama" är den kanoniska lokala AI-kombinationen eftersom Ollama gör modellhantering dödsenkelt.

Varför kan Open WebUI inte ansluta till Ollama?

Vanligaste orsaken: saknad --add-host=host.docker.internal:host-gateway-flagga och OLLAMA_BASE_URL inte inställt i Open WebUI:s inställningar. Näst vanligaste: Ollama bunden till enbart 127.0.0.1, onåbar inifrån containern — fixa med OLLAMA_HOST=0.0.0.0:11434 ollama serve. Kör docker exec open-webui curl http://host.docker.internal:11434/api/tags för snabb diagnostik.

Hur lägger jag till modeller i Open WebUI?

Enklaste vägen: från värden, kör ollama pull llama3.2:3b (eller valfri modell från ollama.com/library). Modellen visas automatiskt i Open WebUI:s rullgardinsmeny — ingen omstart behövs. Alternativt, i Open WebUI gå till Admin → Inställningar → Anslutningar → Ollama och använd pull-knappen i gränssnittet. Hur som helst bor modellerna på Ollama-sidan.

Vad är skillnaden mellan Open WebUI och LM Studio?

LM Studio är en single-user desktop-app fokuserad på modellhantering plus chatt — starka GPU-standardinställningar, snyggt gränssnitt, ingen fleranvändare. Open WebUI är en självhostad server som stöder flera användare, inbyggd RAG, röst I/O, Pipelines/Functions och MCP. Olika målgrupper: LM Studio för solo desktop-powerusers, Open WebUI för team eller alla som vill ha en utbyggbar privat ChatGPT.

Kan jag använda Open WebUI på en telefon?

Ja — Open WebUI är helt responsivt, så alla mobila webbläsare fungerar. Para ihop det med HTTPS (Caddy med ett Let's Encrypt-certifikat eller en Cloudflare Tunnel) och det blir en fullt funktionell mobil chattapp. Lägg till det på din hemskärm på iOS eller Android för en nästan native PWA-upplevelse. Exponera det inte offentligt utan autentisering.

Hur uppdaterar jag Open WebUI?

Hämta den senaste bilden och starta om: docker pull ghcr.io/open-webui/open-webui:main && docker stop open-webui && docker rm open-webui och kör sedan ditt ursprungliga docker run-kommando igen. Namngivna volymer bevarar all data — chatthistorik, användare, RAG-samlingar och inställningar. Med Docker Compose: docker compose pull && docker compose up -d. Uppdateringar levereras ungefär varje vecka.

Stöder Open WebUI röstchatt?

Ja — både tal-till-text (via lokal faster-whisper) och text-till-tal (via OpenAIs TTS API eller lokal coqui-tts). Konfigurera båda i Admin → Inställningar → Ljud. När det är aktiverat visas en mikrofonikon i chattrutan. Den pragmatiska konfigurationen är lokal Whisper plus OpenAI TTS — helt offline-indata, snabb ren utdata. Se avsnittet Röst I/O ovan för miljövariabel-konfiguration.

Hur lägger jag till mina PDF:er i Open WebUI?

Klicka på din profil → Workspace → Kunskap → Ny samling, ladda sedan upp PDF:er, Word-dokument, Markdown eller textfiler. Open WebUI delar upp dokumenten i bitar, bäddar in dem med nomic-embed-text (hämta det först via ollama pull nomic-embed-text) och lagrar dem i ChromaDB. Referera till en samling i chatten med #samlingsnamn eller bifoga den permanent till en Anpassad Modell.