CtrlK
Open WebUI is a self-hosted, extensible web interface for interacting with large language models (LLMs) both locally and through cloud APIs. Originally launched as Ollama WebUI in October 2023 by Timothy Jaeryang Baek, the project was renamed to Open WebUI in January 2024 to reflect its expanding support for multiple LLM backends beyond Ollama. Open WebUI provides a polished, ChatGPT-style user experience while allowing users to maintain full control over their data and infrastructure. As of March 2026, the project has accumulated over 128,000 stars on GitHub and attracted a community of more than 355,000 members, making it one of the most popular open-source AI interface projects in existence.
The platform supports a wide range of LLM providers through the OpenAI-compatible Chat Completions protocol, including Ollama for local models, OpenAI's API, Anthropic's Claude, Google Gemini, Mistral AI, DeepSeek, Groq, and many others. Its feature set spans retrieval-augmented generation (RAG), web search integration, image generation, voice interaction, role-based access control (RBAC), a plugin framework called Pipelines, native Model Context Protocol (MCP) support, and Python code execution in the browser.
Timothy Jaeryang Baek created the project under the name "Ollama WebUI" with the first public release (v0.1.102) on September 25, 2023, followed by the GitHub repository creation on October 6, 2023. Baek holds a First-Class Honours degree in Computer Science from the University of London and a Master's degree in Computer Science from Simon Fraser University. His goal was to build a user-friendly frontend for Ollama that would make running local LLMs as approachable as using commercial services like ChatGPT.
Early releases focused on core chat functionality and Ollama compatibility. Version 0.1.109 introduced simplified settings management, and v0.1.118 added multi-server load balancing for Ollama instances. A notable milestone came with v0.1.119 in March 2024, which introduced retrieval-augmented generation (RAG) capabilities with dynamic embedding model updates for document processing.
On January 30, 2024, the Ollama team contacted Baek with concerns about trademark confusion, stating: "We want to avoid confusion for our users. I think people are getting confused about Ollama-webui and Ollamahub as official Ollama trademarked items." In response, the community held a discussion on GitHub (Discussion #602) to choose a new name, with two options considered: "One-webui" and "Open-webui." The community selected "Open WebUI," and the project was rebranded accordingly. This rename also aligned with the project's expanding scope, as it had begun supporting additional backends such as llama.cpp, LiteLLM, and vLLM alongside Ollama.
Open WebUI rapidly gained popularity throughout 2024. The project was selected for the 2024 GitHub Accelerator program as one of 11 open-source AI projects. Baek's stated motivation was to provide opportunities for individuals with limited or no internet access to use AI technology and its benefits. In September 2024, the project joined the inaugural Mozilla Builders Accelerator cohort, an intensive 12-week build-sprint program culminating in a demo day in San Francisco. Open WebUI, Inc. was incorporated as a company, raising a total of $40,000 through these two accelerator/incubator rounds.
Version 0.2.0, released in June 2024, introduced the Pipelines plugin framework for custom logic and function calling. Subsequent versions added features like the community marketplace, OpenAI-compatible API support for third-party providers, and enterprise authentication options. By late 2024, the project had surpassed 40,000 GitHub stars. Growth continued through 2025 and into 2026, with the repository reaching over 128,000 stars, 18,100+ forks, and 15,700+ commits by March 2026.
Open WebUI follows a three-tier architecture composed of a frontend, backend, and data layer.
The user interface is built with SvelteKit using Svelte 5 and TypeScript. Styling is handled by Tailwind CSS, and Vite is used as the build tool for fast development builds and production bundling. The frontend is a single-page application (SPA) that communicates with the backend through HTTP REST endpoints, with all HTTP requests including an Authorization Bearer token header. Socket.IO handles real-time features like streaming chat responses and push notifications.
The server-side application is written in Python 3.11+ using FastAPI, an asynchronous web framework. FastAPI provides high performance, automatic OpenAPI documentation generation, and native async support. The backend serves both the RESTful API endpoints and the compiled SvelteKit frontend from the same host, simplifying deployment and reducing infrastructure complexity. The backend also includes an integrated inference engine for local RAG processing.
SQLAlchemy serves as the object-relational mapper for database interactions. Open WebUI supports both SQLite (default for single-instance deployments) and PostgreSQL for production and multi-replica setups. For encrypted storage, SQLCipher is available as an option. Redis is used for caching and managing distributed WebSocket sessions in scaled deployments.
| Component | Technology | Purpose |
|---|---|---|
| Frontend | SvelteKit (Svelte 5), TypeScript, Tailwind CSS | User interface and SPA rendering |
| Build Tool | Vite | Fast development builds and bundling |
| Backend | Python 3.11+, FastAPI | API server and business logic |
| ORM | SQLAlchemy | Database abstraction |
| Database | SQLite or PostgreSQL | Persistent data storage |
| Encrypted DB | SQLCipher | Encrypted database support |
| Real-time | Socket.IO | Streaming responses, notifications |
| Caching | Redis | Session management, distributed state |
| Containerization | Docker | Deployment and distribution |
Open WebUI connects to LLM providers through the OpenAI Chat Completions protocol, making it compatible with any service that follows this standard. Rather than building specific modules for individual providers, the platform is designed around this universal protocol. Supported backends include:
| Provider | Connection Method | Notes |
|---|---|---|
| Ollama | Native integration | Local model inference with multi-instance load balancing |
| OpenAI | Direct API | GPT-4, GPT-4o, o1, o3 series |
| Anthropic | Built-in compatibility layer | Auto-detects Anthropic URLs, handles model discovery |
| Google Gemini | OpenAI-compatible endpoint | Gemini Pro, Ultra, Flash |
| Mistral AI | OpenAI-compatible | Full /models auto-detection |
| DeepSeek | OpenAI-compatible | Full /models auto-detection |
| Groq | OpenAI-compatible | Fast inference |
| LiteLLM | Proxy server | Unified access to 100+ providers including AWS Bedrock, Azure, Cohere |
Users can run multiple models concurrently and switch between them within a single conversation. The model selector supports fuzzy search, and administrators can filter which models are visible to different user groups. Open WebUI also supports uploading GGUF files directly to create new Ollama models and importing TavernAI Character Cards for character-based interactions.
The Model Builder feature allows users to create custom model presets that wrap any base model (including cloud models like GPT-4 or Claude) with specific configurations. Users can bind system prompts, knowledge collections, tools, and dynamic variables to a model, creating specialized agents for particular tasks. Key customization options include:
Custom agents can be edited, cloned, shared, exported, and hidden through the Models management interface. The Model Playground (currently in beta) provides a testing environment for experimenting with model configurations before deploying them to users.
The chat interface draws inspiration from ChatGPT's design while adding several enhancements:
Chat management features include conversation tagging (with auto-tagging), chat folders with drag-and-drop organization, pinned chats for quick access, chat cloning, bulk archival, and the ability to export conversations as JSON, PDF, or plain text. Chat history can be toggled on or off per conversation, and entire conversation histories can be imported or exported for backup purposes.
Open WebUI includes a built-in RAG pipeline that allows users to upload documents and query them alongside LLM conversations. The system supports multiple content extraction engines for processing various file formats:
Supported file types include PDFs, Word documents, Excel spreadsheets, and many other formats through these extraction engines.
For vector storage, Open WebUI supports nine database backends:
| Vector Database | Maintainer | Multi-Tenancy Support |
|---|---|---|
| ChromaDB | Official (default) | No |
| PostgreSQL with PGVector | Official | No |
| Qdrant | Community | Yes |
| Milvus | Community | Yes |
| Elasticsearch | Community | No |
| OpenSearch | Community | No |
| Pinecone | Community | No |
| S3Vector | Community | No |
| Oracle 23ai | Community | No |
Only ChromaDB and PGVector are consistently maintained by the Open WebUI team; the remaining vector stores are community contributions. For multi-replica deployments, an external vector database (PGVector, Milvus, or Qdrant) is required since the default embedded ChromaDB does not support shared access.
The RAG system offers hybrid search combining BM25 keyword matching with vector similarity, and re-ranking powered by CrossEncoder models. Relevance score thresholds are configurable, and citations with relevance percentages appear inline in responses. A dedicated YouTube RAG pipeline enables summarization and interaction with video transcripts through URLs.
Open WebUI integrates with over 15 web search providers to inject real-time information into LLM conversations. Supported providers include SearXNG, Google PSE, Brave Search, Kagi, Mojeek, Bocha, Tavily, Perplexity, serpstack, Serper, Serply, DuckDuckGo, SearchApi, SerpApi, Bing, Jina, Exa, Sougou, Azure AI Search, and Ollama Cloud.
When Native Function Calling (Agentic Mode) is enabled, capable models can independently explore the web, verify facts, and follow links autonomously, turning the web search feature into a full agentic research system. This represents a significant evolution from the earlier simple result injection approach.
Open WebUI supports image generation and editing through multiple backends:
Both generation from text prompts and prompt-based editing of existing images are supported.
Open WebUI provides both speech-to-text (STT) and text-to-speech (TTS) capabilities through multiple providers.
Speech-to-Text providers:
Text-to-Speech providers:
Voice interaction features include hands-free voice calls with vision model support for video conversations, tap-to-interrupt and voice interrupt capabilities, and customizable audio playback speed.
Open WebUI implements a three-layer access control system designed for multi-user environments:
Roles: Three built-in roles define high-level user types.
| Role | Description | Key Capabilities |
|---|---|---|
| Admin | Full system access | User management, system settings, model control, chat oversight of all non-admin users |
| User | Standard access | Chat, document upload, access to assigned models and tools |
| Pending | Awaiting approval | Can log in but sees only an activation pending screen with admin contact info |
Permissions: Granular feature flags such as "Can Delete Chats," "Can Use Web Search," and model-level access controls. Administrators configure default permissions for all users through the Admin Panel and can create groups with specific permission overrides.
Groups: Organizational units for managing shared access to resources. Groups can override default permissions, and model-level permissions control which users or groups can access specific models, enabling fine-grained resource allocation.
The first user to sign up automatically receives the Admin role. The default role for new users is "Pending," requiring administrator approval before they can use the system. Administrators can manage all users except other administrators and cannot change their own role or that of the first administrator account.
Open WebUI provides three extensibility mechanisms for customizing and extending the platform:
Tools are Python-based extensions that give LLMs capabilities beyond their default abilities, such as retrieving live information, performing web searches, generating images, or interacting with external APIs and services. Tools are installed from the community marketplace with a single click or written in the built-in code editor and can be assigned to any LLM that supports function calling. Each tool runs as a callable function that the model can invoke during a conversation.
Functions extend the Open WebUI platform itself rather than the LLMs. They can add support for new AI model providers (such as Anthropic or Vertex AI), create custom UI buttons, implement message filters for content moderation, or add new processing pipelines. Functions are easier to write and deploy than Pipelines since they run within the main Open WebUI process.
Pipelines is a separate, UI-agnostic OpenAI-compatible plugin framework (available as its own Docker container at github.com/open-webui/pipelines) designed for more complex orchestration that benefits from a separate service. Pre-built pipelines include:
Starting with version 0.6.31, Open WebUI natively supports Model Context Protocol (MCP) via Streamable HTTP transport. This design reflects the platform's web-based, multi-tenant architecture where browsers operate within sandboxed, event-driven HTTP constraints. Users can configure local MCP servers and have their models use them as tools during conversations.
For MCP servers that use stdio or SSE transport, the open-source mcpo proxy (also developed by the Open WebUI team at github.com/open-webui/mcpo) translates those protocols into OpenAPI-compatible endpoints, allowing traditional MCP tools to function within Open WebUI without transport layer modifications.
The built-in analytics dashboard (accessible only to administrators via Admin Panel > Analytics) provides a comprehensive view of instance activity. Key metrics include message volume across different models and time periods, and token usage tracking for cost estimation and resource planning. Token data is automatically captured from model responses and normalized across different providers (OpenAI, Ollama, llama.cpp, and others) to provide consistent metrics regardless of the backend in use.
For production deployments, Open WebUI supports OpenTelemetry integration for observability, and third-party monitoring solutions such as Grafana dashboards and DataDog LLM Observability are available through community-developed functions.
Open WebUI supports enterprise-grade authentication and compliance features:
Docker is the primary deployment method for Open WebUI. The basic installation command pulls the latest image from the GitHub Container Registry:
docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
The -v open-webui:/app/backend/data volume mount is required to persist the database and uploaded files across container restarts. Without this volume, data will be lost when the container is removed.
Open WebUI provides several Docker image variants:
| Image Tag | Description | Use Case |
|---|---|---|
:main | Standard image with bundled components | General deployment |
:cuda | Includes NVIDIA CUDA support | GPU-accelerated inference |
:ollama | Bundled with Ollama | Single-container local LLM setup |
| Slim variants | Smaller images without pre-bundled models | Low-bandwidth or storage-limited environments |
For GPU acceleration, the NVIDIA CUDA Container Toolkit must be installed on the host system (Linux or WSL). If the Open WebUI container cannot reach an Ollama server on the same machine, the --network=host flag can resolve connectivity issues.
Docker Compose files are provided for multi-container setups, including configurations for Open WebUI with Ollama, Redis, PostgreSQL, and external vector databases. Docker Compose is also the recommended method for integrating with Docker Model Runner.
pip install open-webui) for native installation without DockerFor multi-replica deployments, Open WebUI requires:
Production observability is available through OpenTelemetry integration, and HTTP/S proxy support allows deployment behind corporate firewalls and reverse proxies.
The Open WebUI Community (openwebui.com) serves as a marketplace where users share and discover tools, functions, models, and prompts. With over 355,000 community members, the marketplace allows one-click importing of extensions directly into a running Open WebUI instance. No coding is required to install community-created tools and functions.
The community also features a model evaluation arena for A/B testing between models, a leaderboard with ELO ratings for ranking model performance, and RLHF annotation capabilities with 1-to-10 rating scales for collecting human feedback on model outputs.
Open WebUI includes a Channels feature (currently in beta, requiring administrator activation) that provides Discord- and Slack-style persistent, topic-based rooms within the platform. Unlike standard chats, which are isolated sessions, Channels allow multiple users and multiple AI models to interact in a shared timeline. Users can add emoji reactions, pin important messages, reply in threads, and ask AI models to summarize channel activity. This feature transforms Open WebUI from a personal interface into a collaborative workspace for teams.
Beyond Channels, Open WebUI offers several collaboration tools: local chat sharing with centralized management and the ability to audit or revoke shared conversation access, a unified collaborative workspace for teams, and community sharing through the Open WebUI Community platform where users can publish and discover shared resources.
| Feature | Open WebUI | LM Studio | text-generation-webui (Oobabooga) | AnythingLLM |
|---|---|---|---|---|
| Interface Type | Web (browser) | Desktop application | Web (browser) | Desktop and web |
| Primary Use Case | Multi-user team deployment | Single-user local inference | Power-user experimentation | Document-focused RAG |
| Multi-Backend Support | Yes (OpenAI protocol) | Built-in engine only | Multiple backends | Multiple backends |
| RAG | Built-in with 9 vector DBs | Limited | Community extensions | Built-in |
| User Management/RBAC | Yes (Admin, User, Pending) | No | No | Yes |
| Docker Deployment | Primary method | N/A (desktop app) | Supported | Supported |
| Plugin System | Tools, Functions, Pipelines | No | Extensions | No |
| SSO/LDAP/OAuth | Yes | No | No | Yes |
| MCP Support | Native (v0.6.31+) | No | No | No |
| Image Generation | DALL-E, ComfyUI, AUTOMATIC1111 | No | Integrated | No |
| Voice I/O | STT + TTS (multiple providers) | No | Extensions | No |
| Analytics Dashboard | Built-in (admin) | No | No | No |
| License | Open WebUI License (permissive) | Proprietary | AGPL-3.0 | MIT |
| GitHub Stars (March 2026) | 128,000+ | N/A (closed source) | 42,000+ | 35,000+ |
Open WebUI's licensing has evolved over the project's history. The license progression was: Apache 2.0 (initial), MIT, CC BY-NC-SA 4.0, MIT (again), BSD 3-Clause, and finally the current Open WebUI License starting with version 0.6.6 in April 2025.
The current Open WebUI License is based on BSD 3-Clause but adds a branding protection clause. Users must keep "Open WebUI" branding visible in their deployments unless one of three conditions is met:
All external and community-contributed code merged before version 0.6.6 remains under pure BSD 3-Clause with no retroactive relicensing. New contributors after v0.6.5 must sign a Contributor License Agreement (CLA). The project tracks its complete license history in a LICENSE_HISTORY file in the repository.
While this license is not OSI-certified as "open source" due to the branding clause, Open WebUI remains free to use, modify, and redistribute for any purpose. The branding requirement was introduced to prevent bad actors from stripping the project's identity and reselling the software without attribution.
The project is funded through advertising sponsors, GitHub Sponsors donations, and enterprise support agreements. Open WebUI, Inc. manages the project's strategic and operational decisions, led openly by founder Tim J. Baek.