How to Use Open WebUI: A Friendly, Step‑by‑Step Guide for Faster AI Workflows

Q: 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.

If you’ve ever wished ChatGPT had a customizable, self‑hosted twin you could wire into your own models and data, Open WebUI is exactly that. It’s a modern, lightweight interface for chatting with local or remote large language models (LLMs), managing prompts, building RAG (Retrieval‑Augmented Generation) workflows, and collaborating with teammates—all from your browser.

In this practical, solution‑oriented guide, we’ll walk through how to use Open WebUI end‑to‑end: setup options, connecting to Ollama or APIs, managing models, building retrieval flows, securing your instance, and a handful of pro tips. By the end, you’ll be able to run powerful AI workflows on your own terms—fast.

What Is Open WebUI (and Why Use It)?

Open WebUI is a self‑hostable web interface for LLMs. Think of it as the command center for your AI interactions—bring your own models (local or cloud), craft reusable prompts, add your documents, and collaborate through a clean, intuitive UI. It’s especially popular with developers, data teams, and privacy‑conscious users who want control, extensibility, and speed.

Key reasons people choose Open WebUI:

Own your data: Run locally or on your server.

Flexible backends: Connect to local engines like Ollama or remote providers via API.

Workflow‑ready: RAG, tools, embeddings, and structured prompts.

Admin controls: API key management, authentication, and environment configuration.

The Fastest Way to Start: Docker Quick Start

If you’re comfortable with Docker, you can be up and running in minutes.

Pull the image

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

Run the container

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

Open your browser and visit

You’ll land on the UI, create an admin account, and you’re ready to connect models.

Tip: For persistent storage and environment variables (like API key restrictions and auth), switch to a docker-compose.yml so you can mount volumes and define configuration cleanly.

Connecting to Models: Local (Ollama) or Cloud APIs

Open WebUI is backend‑agnostic. You can:

Use Ollama to run models locally (e.g., Llama 3, Phi‑3, Mistral). This is great for privacy and offline work.

Use cloud APIs like OpenAI, Anthropic, Google, or others via API keys.

Option A: Use Ollama Locally

Install Ollama (macOS, Linux, Windows)

Visit ` to install.

Pull a model with Ollama

ollama pull llama3

You can replace llama3 with models like mistral, phi3, or llama3:instruct depending on your needs.

Start Open WebUI

Ensure Open WebUI can reach Ollama’s local endpoint (usually `).

In Open WebUI, go to Admin Settings → Connections → Ollama

Add the endpoint, choose default model(s), and test the connection.

Now you can chat with local models directly in the browser.

Option B: Use Cloud Providers via API Keys

In Admin Settings → Providers (or API/Keys)

Add keys for OpenAI, Anthropic, or Google.

Choose a default model per provider

For example: gpt-4o-mini (OpenAI), claude‑3‑haiku (Anthropic), or gemini‑1.5‑flash (Google).

Set limits

Enforce rate limits, usage scopes, or per‑user keys depending on your team setup.

This hybrid approach (local + cloud) is common: quick drafts on local models, then refine with a cloud model when needed.

Your First Chat: Prompts, Modes, and Attachments

Once a model is connected, start a new chat. A few basics:

Prompt templates: Save frequently used instructions (system prompts) like “You are my Python tutor—explain with examples and tests.”

Modes: Switch between creative, concise, or technical styles by adjusting system prompts or temperature.

Attachments: Upload files (PDFs, TXT, CSV) for the model to reference. For large or recurring corpora, create a knowledge base with embeddings (see RAG below).

Pro tip: Organize chats by project. Use tags like #docs, #code, or #analysis so future you can find things fast.

Build RAG in Minutes: Knowledge, Embeddings, and Search

RAG (Retrieval‑Augmented Generation) lets your model answer questions with your content (docs, notes, policies, code). Here’s how to put it together:

Create a Knowledge Base (KB)

In the sidebar, create a new KB or “Collections.”

Upload documents: PDFs, markdown, HTML, or text files.

Generate Embeddings

Choose the embeddings backend (local via Ollama if you have an embeddings model, or a cloud provider through API).

Index your documents; larger sets may take a few minutes.

Enable Retrieval in Chat

In a chat, toggle retrieval and select your KB.

Ask questions like “Summarize our onboarding policy and list action items,” or “What exceptions do we allow in the security policy?”

Iterate

Inspect sources, refine your documents, adjust chunking size, and re‑embed if answers seem off.

Pro tip: Maintain separate KBs for accuracy (e.g., “Marketing copy,” “Legal policies,” “Runbooks”). This reduces irrelevant retrievals.

Actions, Tools, and Workflows

Open WebUI supports tool‑driven interactions so the model can “do things,” not just chat. Depending on your setup, you can:

Call functions/tools you define (e.g., run a script, fetch a URL, query a database).

Use system prompt workflows to structure multi‑step tasks.

Add plugins/extensions if your deployment supports them.

Example: A “Content Brief” workflow

Step 1: Ask the model to extract keywords from a topic.

Step 2: Research via a web tool (if enabled) and summarize sources.

Step 3: Draft an outline + title variants.

Step 4: Create a short/long version.

Save these steps in a reusable template so your team can run them with one click.

Managing Models Like a Pro

Multiple defaults: Set per‑workspace or per‑chat defaults (e.g., fast local for brainstorming, precise cloud for final copy).

Model cards: Document what each model does best—“Use Llama 3 for code, Mistral for concise summaries.”

Batch tasks: Use longer system prompts and structured output (JSON, checklists) for repeatable tasks like QA checks, translation, or tagging.

Admin Settings: Security and Governance

If you’re self‑hosting for a team, take a few minutes to harden and govern your instance.

Authentication: Require sign‑in. If available, enable SSO/OIDC.

API key policies: Limit which providers can be used, scope keys by user/role, and restrict egress where appropriate.

Environment variables: Configure things like model endpoint URLs, embedding backends, and key restrictions via env settings.

Rate limits and quotas: Prevent runaway costs with per‑user or per‑workspace limits.

Auditability: Encourage teams to label chats and store summaries so you can trace decisions.

Dev tip: Put Open WebUI behind a reverse proxy (e.g., Nginx/Caddy) with HTTPS and set allowed origins.

Team Collaboration and Knowledge Hygiene

Shared prompts and KBs: Create curated prompt libraries and knowledge bases. Assign maintainers.

Version content: For policy docs or specs, store sources in Git or a doc hub and re‑embed when updated.

Source‑first answers: Encourage users to click citations and scan original docs. Trust, but verify.

Everyday Use Cases (Copy These)

Content & marketing

Turn a brief into three audience‑specific drafts.

Generate SEO outlines, FAQs, and titles.

Engineering

Explain a function and generate edge‑case tests.

Summarize PRs and produce release notes.

Ops & support

Build a KB from runbooks and SOPs.

Draft responses using your tone/style guide.

Research & strategy

Summarize 10 docs into a 1‑pager with citations.

Compare vendors using a structured matrix.

Troubleshooting: Quick Fixes

“Can’t connect to Ollama”

Check Ollama is running: `curl

Verify network access from the container to the host.

“Model not found”

Pull the model via Ollama: ollama pull mistral

For cloud, confirm the exact model name and permissions.

“RAG results look irrelevant”

Re‑embed with a better embeddings model.

Adjust chunk size (e.g., 500–1,000 tokens) and overlap.

Split your KB into smaller, topical collections.

“Costs spiking”

Set rate limits and default to local models for drafts.

Performance Tips and Advanced Moves

Use smaller local models for ideation and larger/cloud models for finalization.

Cache frequent prompts and responses where possible.

Adopt structured outputs (JSON, bullet checklists) for downstream automations.

For sensitive data, keep everything local (Ollama + local embeddings + on‑prem storage).

Use system prompts to define tone, formatting, and guardrails.

Worth Noting: Pairing Open WebUI with Sider.AI

If you produce lots of content or research, a workflow companion can help. Worth noting: Sider.AI assists with drafting, summarizing, and organizing long‑form work. You can ideate or retrieve context in Open WebUI, then use Sider.AI’s editor‑style assistance to polish, restructure, and SEO‑optimize articles for publishing. It’s a helpful pairing when you want both control (self‑hosted chat + RAG) and speed (collaborative editing and optimization).

A Simple Starter Blueprint

Run Open WebUI via Docker.

Install Ollama, pull llama3 and mistral.

Connect Open WebUI to and setmistral` as default for chat.

Create KBs: Policies, Marketing, Runbooks; embed with a strong embeddings model.

Save three prompt templates: “Summarizer with bullets,” “SEO outline generator,” and “Release notes writer.”

Add rate limits and require login.

With this setup, most teams can cover 80% of daily AI tasks.

Key Takeaways

Open WebUI gives you a clean, controllable UI to work with local and cloud LLMs.

For privacy and speed, pair it with Ollama locally; mix in cloud models when needed.

Use RAG to ground answers in your documents; keep KBs small and focused.

Secure your instance with auth, key policies, and rate limits.

Standardize prompts and outputs so your team’s work is consistent and automatable.

Next Steps

Spin up Open WebUI with Docker and connect to Ollama.

Create your first knowledge base and try a retrieval‑backed chat.

Save three prompt templates your team will reuse daily.

If you publish content, pass drafts through Sider.AI to refine tone, structure, and SEO before going live.

FAQ

Q1: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.

Q2: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.

Q3: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.

Q4: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.

Q5: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.