What is Open WebUI used for?

Open WebUI is a self-hosted interface for large language models. It lets you chat with local or cloud models, build RAG workflows with your documents, and manage prompts and teams in one place.

How do I use Open WebUI with Ollama?

Install Ollama, pull a model like `llama3` or `mistral`, and then point Open WebUI’s Ollama connection to `http://localhost:11434`. You can set a default model and start chatting locally with full privacy.

Can Open WebUI do RAG with my PDFs and notes?

Yes. Create a knowledge base, upload documents, generate embeddings, and enable retrieval in chat. The model will cite and summarize from your own sources for grounded answers.

Is Open WebUI secure for teams?

You can enforce sign-in, manage API keys by role, and set rate limits. For production, use HTTPS behind a reverse proxy and restrict which providers or endpoints are allowed.

Should I use local or cloud models in Open WebUI?

Use local models for privacy, speed, and cost control; use cloud models for complex tasks requiring higher quality. Many teams combine both and set chat-specific defaults.

Hur man använder Open WebUI: En vänlig steg-för-steg-guide för snabbare AI-arbetsflöden

Om du någonsin önskat att ChatGPT hade en anpassningsbar, självhyst tvilling du kunde koppla till dina egna modeller och data, är Open WebUI precis det. Det är ett modernt, lättviktigt gränssnitt för att chatta med lokala eller fjärranslutna stora språkmodeller (LLM), hantera prompter, bygga RAG-arbetsflöden (Retrieval-Augmented Generation) och samarbeta med teammedlemmar – allt från din webbläsare.

I den här praktiska, lösningsorienterade guiden går vi igenom hur man använder Open WebUI från början till slut: installationsalternativ, anslutning till Ollama eller API:er, hantering av modeller, byggande av hämtningsflöden, säkring av din instans och en handfull proffstips. I slutet kommer du att kunna köra kraftfulla AI-arbetsflöden på dina egna villkor – snabbt.

Vad är Open WebUI (och varför använda det)?

Open WebUI är ett självhystbart webbgränssnitt för LLM:er. Tänk på det som kommandocentralen för dina AI-interaktioner – ta med dina egna modeller (lokala eller i molnet), skapa återanvändbara prompter, lägg till dina dokument och samarbeta genom ett rent, intuitivt användargränssnitt. Det är särskilt populärt bland utvecklare, datateam och integritetsmedvetna användare som vill ha kontroll, utbyggbarhet och snabbhet.

De viktigaste anledningarna till att folk väljer Open WebUI:

Äg din data: Kör lokalt eller på din server.

Flexibla backend-system: Anslut till lokala motorer som Ollama eller fjärrleverantörer via API.

Arbetsflödesredo: RAG, verktyg, inbäddningar och strukturerade prompter.

Administratörskontroller: API-nyckelhantering, autentisering och miljökonfiguration.

Det snabbaste sättet att starta: Docker Quick Start

Om du är bekväm med Docker kan du vara igång på några minuter.

Hämta bilden

docker pull ghcr.io/open-webui/open-webui:main

Kör containern

docker run -d --name open-webui -p 3000:8080 ghcr.io/open-webui/open-webui:main

Öppna din webbläsare och besök

Du kommer till användargränssnittet, skapar ett administratörskonto och är redo att ansluta modeller.

Tips: För persistent lagring och miljövariabler (som API-nyckelbegränsningar och autentisering), byt till en docker-compose.yml så att du kan montera volymer och definiera konfigurationen tydligt.

Ansluta till modeller: Lokala (Ollama) eller moln-API:er

Open WebUI är backend-agnostisk. Du kan:

Använda Ollama för att köra modeller lokalt (t.ex. Llama 3, Phi-3, Mistral). Detta är bra för integritet och offline-arbete.

Använda moln-API:er som OpenAI, Anthropic, Google eller andra via API-nycklar.

Alternativ A: Använd Ollama lokalt

Installera Ollama (macOS, Linux, Windows)

Besök ` för att installera.

Hämta en modell med Ollama

ollama pull llama3

Du kan ersätta llama3 med modeller som mistral, phi3 eller llama3:instruct beroende på dina behov.

Starta Open WebUI

Se till att Open WebUI kan nå Ollamas lokala slutpunkt (vanligtvis `).

I Open WebUI, gå till Admin Settings → Connections → Ollama

Lägg till slutpunkten, välj standardmodell(er) och testa anslutningen.

Nu kan du chatta med lokala modeller direkt i webbläsaren.

Alternativ B: Använd molnleverantörer via API-nycklar

I Admin Settings → Providers (eller API/Keys)

Lägg till nycklar för OpenAI, Anthropic eller Google.

Välj en standardmodell per leverantör

Till exempel: gpt-4o-mini (OpenAI), claude‑3‑haiku (Anthropic) eller gemini‑1.5‑flash (Google).

Ange gränser

Tvinga fram hastighetsbegränsningar, användningsomfattningar eller nycklar per användare beroende på din teamkonfiguration.

Denna hybridmetod (lokal + moln) är vanlig: snabba utkast på lokala modeller, förfina sedan med en molnmodell vid behov.

Din första chatt: Prompter, lägen och bilagor

När en modell är ansluten, starta en ny chatt. Några grundläggande:

Promptmallar: Spara ofta använda instruktioner (systemprompter) som "Du är min Python-handledare – förklara med exempel och tester."

Lägen: Växla mellan kreativa, koncisa eller tekniska stilar genom att justera systemprompter eller temperatur.

Bilagor: Ladda upp filer (PDF:er, TXT, CSV) som modellen kan referera till. För stora eller återkommande korpusar, skapa en kunskapsbas med inbäddningar (se RAG nedan).

Proffstips: Organisera chattar efter projekt. Använd taggar som #docs, #code eller #analysis så att framtida du kan hitta saker snabbt.

Bygg RAG på några minuter: Kunskap, inbäddningar och sökning

RAG (Retrieval-Augmented Generation) låter din modell svara på frågor med ditt innehåll (dokument, anteckningar, policyer, kod). Här är hur du sätter ihop det:

Skapa en kunskapsbas (KB)

I sidofältet, skapa en ny KB eller "Samlingar".

Ladda upp dokument: PDF:er, markdown, HTML eller textfiler.

Generera inbäddningar

Välj inbäddningsbackend (lokal via Ollama om du har en inbäddningsmodell, eller en molnleverantör via API).

Indexera dina dokument; större uppsättningar kan ta några minuter.

Aktivera hämtning i chatt

I en chatt, växla hämtning och välj din KB.

Ställ frågor som "Sammanfatta vår introduktionspolicy och lista åtgärdspunkter" eller "Vilka undantag tillåter vi i säkerhetspolicyn?"

Iterera

Inspektera källor, förfina dina dokument, justera chunking-storlek och bädda in igen om svaren verkar felaktiga.

Proffstips: Underhåll separata KB:er för noggrannhet (t.ex. "Marknadsföringstext", "Juridiska policyer", "Runbooks"). Detta minskar irrelevanta hämtningar.

Åtgärder, verktyg och arbetsflöden

Open WebUI stöder verktygsdrivna interaktioner så att modellen kan "göra saker", inte bara chatta. Beroende på din konfiguration kan du:

Anropa funktioner/verktyg du definierar (t.ex. kör ett skript, hämta en URL, fråga en databas).

Använda systemprompt-arbetsflöden för att strukturera flerstegsuppgifter.

Lägga till plugins/tillägg om din distribution stöder dem.

Exempel: Ett arbetsflöde för "Innehållsöversikt"

Steg 1: Be modellen att extrahera nyckelord från ett ämne.

Steg 2: Undersök via ett webbverktyg (om det är aktiverat) och sammanfatta källor.

Steg 3: Utarbeta en disposition + titelvarianter.

Steg 4: Skapa en kort/lång version.

Spara dessa steg i en återanvändbar mall så att ditt team kan köra dem med ett klick.

Hantera modeller som ett proffs

Flera standardvärden: Ange standardvärden per arbetsyta eller per chatt (t.ex. snabb lokal för brainstorming, exakt moln för slutgiltig kopia).

Modellkort: Dokumentera vad varje modell gör bäst – "Använd Llama 3 för kod, Mistral för koncisa sammanfattningar."

Batch-uppgifter: Använd längre systemprompter och strukturerad utdata (JSON, checklistor) för repeterbara uppgifter som QA-kontroller, översättning eller taggning.

Administratörsinställningar: Säkerhet och styrning

Om du självhystar för ett team, ta några minuter att härda och styra din instans.

Autentisering: Kräv inloggning. Om tillgängligt, aktivera SSO/OIDC.

API-nyckelpolicyer: Begränsa vilka leverantörer som kan användas, begränsa nycklar efter användare/roll och begränsa utgående trafik där det är lämpligt.

Miljövariabler: Konfigurera saker som modellslutpunkts-URL:er, inbäddningsbackends och nyckelbegränsningar via miljöinställningar.

Hastighetsgränser och kvoter: Förhindra skenande kostnader med gränser per användare eller per arbetsyta.

Revisionsbarhet: Uppmuntra team att märka chattar och lagra sammanfattningar så att du kan spåra beslut.

Utvecklartips: Sätt Open WebUI bakom en omvänd proxy (t.ex. Nginx/Caddy) med HTTPS och ange tillåtna ursprung.

Teamsamarbete och kunskapshygien

Delade prompter och KB:er: Skapa kuraterade promptbibliotek och kunskapsbaser. Tilldela underhållare.

Versionsinnehåll: För policydokument eller specifikationer, lagra källor i Git eller en dokumenthubb och bädda in igen när de uppdateras.

Källförsta svar: Uppmuntra användare att klicka på citat och skanna originaldokument. Lita på, men verifiera.

Vardagliga användningsfall (kopiera dessa)

Innehåll och marknadsföring

Förvandla en brief till tre målgruppsspecifika utkast.

Generera SEO-dispositioner, FAQ och titlar.

Ingenjörsvetenskap

Förklara en funktion och generera edge-case-tester.

Sammanfatta PR:er och ta fram release notes.

Drift och support

Bygg en KB från runbooks och SOP:er.

Utarbeta svar med din ton/stilguide.

Forskning och strategi

Sammanfatta 10 dokument till en 1-sida med citat.

Jämför leverantörer med hjälp av en strukturerad matris.

Felsökning: Snabba lösningar

"Kan inte ansluta till Ollama"

Kontrollera att Ollama körs: `curl

Verifiera nätverksåtkomst från containern till värden.

"Modell hittades inte"

Hämta modellen via Ollama: ollama pull mistral

För moln, bekräfta det exakta modellnamnet och behörigheterna.

"RAG-resultat ser irrelevanta ut"

Bädda in igen med en bättre inbäddningsmodell.

Justera chunk-storlek (t.ex. 500–1 000 tokens) och överlappning.

Dela upp din KB i mindre, tematiska samlingar.

"Kostnaderna skjuter i höjden"

Ange hastighetsgränser och använd lokala modeller som standard för utkast.

Prestandatips och avancerade drag

Använd mindre lokala modeller för idégenerering och större/molnmodeller för slutgiltiga versioner.

Cachelagra frekventa prompter och svar där det är möjligt.

Använd strukturerade utdata (JSON, punktlistor) för nedströmsautomatiseringar.

För känslig data, håll allt lokalt (Ollama + lokala inbäddningar + lokal lagring).

Använd systemprompter för att definiera ton, formatering och skyddsräcken.

Värt att notera: Para ihop Open WebUI med Sider.AI

Om du producerar mycket innehåll eller forskning kan en arbetsflödeskompanjon hjälpa till. Värt att notera: Sider.AI hjälper till med att utarbeta, sammanfatta och organisera långformat arbete. Du kan idégenerera eller hämta kontext i Open WebUI och sedan använda Sider.AI:s redigeringsliknande hjälp för att finslipa, omstrukturera och SEO-optimera artiklar för publicering. Det är en hjälpsam parning när du vill ha både kontroll (självhyst chatt + RAG) och snabbhet (samarbetsredigering och optimering).

En enkel startritning

Kör Open WebUI via Docker.

Installera Ollama, hämta llama3 och mistral.

Anslut Open WebUI till och angemistral` som standard för chatt.

Skapa KB:er: Policyer, Marknadsföring, Runbooks; bädda in med en stark inbäddningsmodell.

Spara tre promptmallar: "Sammanfattare med punkter", "SEO-dispositionsgenerator" och "Release notes-skrivare".

Lägg till hastighetsgränser och kräv inloggning.

Med den här konfigurationen kan de flesta team täcka 80 % av de dagliga AI-uppgifterna.

Viktiga slutsatser

Open WebUI ger dig ett rent, kontrollerbart användargränssnitt för att arbeta med lokala och moln-LLM:er.

För integritet och snabbhet, para ihop det med Ollama lokalt; blanda in molnmodeller vid behov.

Använd RAG för att grunda svar i dina dokument; håll KB:er små och fokuserade.

Säkra din instans med autentisering, nyckelpolicyer och hastighetsgränser.

Standardisera prompter och utdata så att ditt teams arbete är konsekvent och automatiserbart.

Nästa steg

Starta Open WebUI med Docker och anslut till Ollama.

Skapa din första kunskapsbas och prova en hämtningsstödd chatt.

Spara tre promptmallar som ditt team kommer att återanvända dagligen.

Om du publicerar innehåll, skicka utkast genom Sider.AI för att förfina ton, struktur och SEO innan du går live.

FAQ

Q1: Vad används Open WebUI till? Open WebUI är ett självhyst gränssnitt för stora språkmodeller. Det låter dig chatta med lokala eller molnmodeller, bygga RAG-arbetsflöden med dina dokument och hantera prompter och team på ett ställe.

Q2: Hur använder jag Open WebUI med Ollama? Installera Ollama, hämta en modell som llama3 eller mistral och peka sedan Open WebUI:s Ollama-anslutning till http://localhost:11434. Du kan ställa in en standardmodell och börja chatta lokalt med fullständig integritet.

Q3: Kan Open WebUI göra RAG med mina PDF:er och anteckningar? Ja. Skapa en kunskapsbas, ladda upp dokument, generera inbäddningar och aktivera hämtning i chatten. Modellen kommer att citera och sammanfatta från dina egna källor för grundade svar.

Q4: Är Open WebUI säkert för team? Du kan tvinga fram inloggning, hantera API-nycklar efter roll och ange hastighetsgränser. För produktion, använd HTTPS bakom en omvänd proxy och begränsa vilka leverantörer eller slutpunkter som är tillåtna.

Q5: Ska jag använda lokala eller molnmodeller i Open WebUI? Använd lokala modeller för integritet, snabbhet och kostnadskontroll; använd molnmodeller för komplexa uppgifter som kräver högre kvalitet. Många team kombinerar båda och ställer in chatt-specifika standardvärden.