Open WebUI: Overview, Key Features, and Getting Started

What it is

Open WebUI is a self-hosted, user-friendly artificial intelligence interface designed to operate as an extensible hub for AI models. Originally created by Timothy Jaeryang Baek, the software has received support from community sponsorships and initiatives such as the Mozilla Builders 2024 program, the GitHub Accelerator 2024, and the A16z Open Source AI Grant 2025.

The software operates as a provider-agnostic platform, meaning it does not lock users into a single model vendor. Instead, it connects directly to local model engines like Ollama as well as external services powered by OpenAI-compatible Application Programming Interfaces (APIs). In computing, an API acts as a software messenger that lets different applications talk to each other. Through these connections, Open WebUI can interact with a variety of providers and inference runtimes, such as LMStudio, vLLM, GroqCloud, Mistral, OpenRouter, and Anthropic. Because the software can function in fully isolated local environments without an internet connection, it allows users to establish sovereign, offline setups where data remains entirely under their control.

Beyond its core web interface, Open WebUI is surrounded by an ecosystem of companion tools:

• Open Terminal & Terminals (Enterprise): An execution environment that provides a terminal shell and a sandboxed file system, enabling models to run scripts, handle files, and correct programming errors.
• Open WebUI Computer: A mobile-first runtime and coding harness that operates directly on personal computers, accessible through web browsers or messaging apps like WhatsApp and Telegram.
• oikb: A synchronization tool designed to continuously feed knowledge bases from more than 45 external platforms, including GitHub, Jira, Confluence, Slack, and Google Drive.
• Native Desktop Application: Dedicated client software available for macOS, Windows, and Linux that includes a system-wide search bar and an integrated llama.cpp engine for local execution.

What it can do

Open WebUI incorporates a wide range of features designed for personal exploration, coding tasks, and team collaboration:

• Multi-Model Workspaces and Benchmarking: Users can initiate conversations that query multiple models simultaneously to compare answers in real time. For administrators evaluating model performance, the platform includes an arena mode, A/B testing utilities, and ELO-rated leaderboards.
• Agentic Code Execution: Through Open Terminal, AI agents gain access to a virtual command line and storage area. Instead of merely outputting code snippets, models can execute scripts, inspect diagnostic messages, resolve syntax or logic faults, and produce downloadable files displayed next to the conversation.
• Retrieval-Augmented Generation (RAG): Retrieval-Augmented Generation is a method where an AI references external documents before answering a prompt, improving accuracy. Open WebUI supports hybrid search that combines standard keyword matching (BM25) with semantic vector search and reranking. It integrates with 9 vector databases: ChromaDB, PGVector, Qdrant, Milvus, Elasticsearch, OpenSearch, Pinecone, S3Vector, and Oracle 23ai. Text can be parsed from documents using content extraction engines such as Apache Tika, Docling, Document Intelligence, Mistral OCR, and PaddleOCR-vl, with files easily referenced in chat using the # command.
• Web Search and Browsing: The system can retrieve live information from search services, including SearXNG, DuckDuckGo, Brave Search, Google Programmable Search Engine, Perplexity, Tavily, Bing, and Azure AI Search. Users can also enter a website address using # followed by a URL to let the model browse and read page contents.
• Collaborative Notes and Channels: Open WebUI includes a rich-text workspace called Notes, which allows text drafting outside chat rooms, AI-assisted rewrites, and direct injection of notes into chat contexts. For group discussions, Channels provides shared timelines where team members and AI models interact using discussion threads, emoji reactions, pins, and specific access controls.
• Scheduling and Automations: The built-in personal and shared calendar tracks events and recurring schedules. Models can manipulate appointments directly through native function calls. In addition, users can schedule recurring prompt automations that record finished outputs onto the calendar.
• Multimodal Audio and Imagery: The platform features hands-free voice and video calling. For speech recognition, it connects to local Whisper, Azure, OpenAI, or Deepgram. For text-to-speech conversion, it links to ElevenLabs, Azure, OpenAI, Transformers, or browser WebAPIs. Image generation and prompt-based image editing are supported through engines such as OpenAI DALL-E, Google Gemini, ComfyUI, and AUTOMATIC1111.
• Workflow Tools and Persistent Memory: A live workflow interface displays checklists as the model completes multi-step actions. Users can also queue new questions while an answer is actively streaming. The software features persistent memory, allowing models to retain user-specific facts across different chat sessions.
• Extensibility and Enterprise Control: Administrators can extend functionality through modular Filters, Actions, Pipes, Tools, and Skills, connecting external systems via OpenAPI servers, Model Context Protocol (MCP), and the MCPO proxy. Organizational controls include role-based access control (RBAC), user grouping, single sign-on (SSO), LDAP/Active Directory, SCIM 2.0 user provisioning, and OpenTelemetry monitoring.

How to get started

Open WebUI offers multiple deployment pathways, including Python package managers, Docker containers, Kubernetes manifests, and standalone desktop software.

Installation with Python pip

When installing Open WebUI natively using pip, the project documentation specifies that Python 3.11 must be used to maintain compatibility.

1. Install the package using pip:

pip install open-webui

2. Launch the application server:

open-webui serve

Once running, the interface is accessible in a web browser at http://localhost:8080.

Installation with uv

Alternatively, the fast Python package runner uv can execute the application:

1. Install uv:

curl -LsSf https://astral.sh/uv/install.sh | sh

2. Run the server using Python 3.11:

DATA_DIR=~/.open-webui uvx --python 3.11 open-webui@latest serve

Installation with Docker

Docker is a common method for deploying containerized applications. When using Docker, mounting the storage volume with -v open-webui:/app/backend/data is required to preserve configuration settings and prevent database loss.

• Standard setup with local Ollama on the same host:

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

• Setup with an explicit secret key:

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

• Setup for Nvidia GPU acceleration:

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

• Setup for OpenAI API access only:

docker run -d -p 3000:8080 -e OPENAI_API_KEY=your_secret_key -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

• Setup connecting to Ollama hosted on another server:

docker run -d -p 3000:8080 -e OLLAMA_BASE_URL=https://example.com -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

• All-in-one container bundling both Open WebUI and Ollama (CPU only):

docker run -d -p 3000:8080 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

• All-in-one container bundling both Open WebUI and Ollama (GPU acceleration):

docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

• Troubleshooting container networking with host mode:

If the container cannot communicate with a local Ollama instance running at 127.0.0.1:11434, the host networking flag can be used (which exposes the interface on port 8080 instead of port 3000):

docker run -d --network=host -v open-webui:/app/backend/data -e OLLAMA_BASE_URL=http://127.0.0.1:11434 --name open-webui --restart always ghcr.io/open-webui/open-webui:main

• Operating in an offline environment:

To prevent the system from attempting to fetch models across the internet, set the offline environment flag:

export HF_HUB_OFFLINE=1

• Native Desktop Application:

Users seeking an installation without container management can download the desktop build from github.com/open-webui/desktop for macOS, Windows, or Linux.

Pricing and requirements

Open WebUI is distributed as an open-source project under the Open WebUI License, which includes requirements to preserve original branding, alongside earlier contributions covered by their original licenses. For commercial support, custom branding, service level agreements, or Long-Term Support options, pricing and plans are subject to the official enterprise page.

System requirements vary depending on how the software is deployed:

• Runtime Environment: Native Python installations via pip or uv require Python 3.11.
• Hardware and Acceleration: Standard setups can run entirely on general-purpose CPUs. For GPU hardware acceleration with Nvidia graphics cards, the system requires the Nvidia CUDA container toolkit on Linux or Windows Subsystem for Linux (WSL).
• Container Footprint: According to the project documentation, the standard :main Docker image requires 1.62 GB of disk space because it bundles internal speech recognition, document extraction engines, and local embedding models. In contrast, according to the project documentation, the :slim image variant requires 196 MB (approximately 88% smaller) because it relies on external services for those functions.
• Storage and Databases: Open WebUI supports SQLite (with optional encryption) or PostgreSQL for its relational database. File storage can reside locally or connect to Amazon S3, Google Cloud Storage, or Azure Blob Storage. Multi-node setups operating behind load balancers can utilize Redis for session coordination.

Who it is for

Open WebUI serves several distinct audiences:

• Local AI Enthusiasts: Individuals running models locally with Ollama, LMStudio, or llama.cpp who want a clean, responsive web interface that functions entirely offline without leaking prompt data.
• Developers and AI Researchers: Technical users who need to evaluate model quality using arena benchmarks, automate tasks with scheduled prompts, run scripts in sandboxed environments, or integrate custom endpoints via the Model Context Protocol.
• Teams and Enterprise Organizations: Groups requiring collaborative workspaces, shared calendar management, and team communication channels, combined with enterprise-grade identity management such as Active Directory, LDAP, single sign-on, and automated SCIM provisioning.

Alternatives

LibreChat is an open-source AI chat platform that provides an interface for interacting with various AI models.

Lobe Chat is an open-source chatbot framework designed to support different artificial intelligence providers.

Sources

• Open WebUI GitHub Repository
• Open WebUI Documentation
• LibreChat GitHub Repository
• Lobe Chat GitHub Repository