Open WebUI Interface: Local LLM Management 👋

This application, Open WebUI, is an extensible platform, boasting numerous features and an intuitive user experience, designed specifically for completely isolated, offline operation. It natively interfaces with various model execution backends, including Ollama and any service exposing an OpenAI-compatible API endpoint. For comprehensive documentation, please consult our Open WebUI Documentation.

Core Capabilities of Open WebUI ⭐

• 🚀 Simplified Deployment: Achieve rapid setup through container orchestration tools like Docker, or Kubernetes via kubectl, kustomize, or helm. Supports specialized images tagged for :ollama or hardware acceleration like :cuda.

• 🤝 API Interoperability: Seamlessly connect to OpenAI-compatible services. Administrators can easily redirect the OpenAI API base URL to interface with systems such as LMStudio, GroqCloud, Mistral, OpenRouter, and similar platforms.

• 🛡️ Fine-Grained Access Control (RBAC): Administrators gain the ability to define detailed user roles and permission sets, establishing a secure operational boundary. This layered security promotes responsible usage and tailored individual experiences.

• 📱 Adaptive Interface: Delivers a consistent, high-quality experience across personal computers, notebooks, and mobile devices.

• 📱 Mobile PWA: Leverage our Progressive Web App implementation for an application-like feel on mobile, including local network offline accessibility.

• ✒️🔢 Comprehensive Text Formatting: Full support for rendering both standard Markdown syntax and complex mathematical notation via LaTeX.

• 🎤📹 Integrated Hands-Free I/O: Features built-in capabilities for voice and video communication, enabling more fluid and interactive dialogue sessions.

• 🛠️ Model Configuration Utility: Facilitates the creation and customization of Ollama models directly within the web interface. Users can design custom agents/characters, fine-tune chat presentation, and import models via the Open WebUI Community repository.

• 🐍 Native Python Tooling: Empower LLMs with integrated code execution environments in the tools section. Implement custom behaviors by injecting pure Python functions via the 'Bring Your Own Function' (BYOF) mechanism.

• 📚 Local Knowledge Retrieval (RAG): Introduces advanced Retrieval Augmented Generation capabilities, allowing direct document interaction during chat. Documents can be loaded into the current session or managed centrally, accessible via the # prefix command in queries.

• 🔍 Augmented Web Search: Integrate results from various search engines—including SearXNG, Google PSE, Brave Search, serpstack, serper, Serply, DuckDuckGo, TavilySearch, SearchApi, and Bing—directly into the conversation context.

• 🌐 Contextual Web Fetching: Incorporate content from external URLs into discussions using the command format # [URL], enriching conversational depth with live web data.

• 🎨 Visual Content Synthesis: Incorporate image creation functionality utilizing backends like AUTOMATIC1111 API, local ComfyUI instances, or the external OpenAI DALL-E service.

• ⚙️ Parallel Model Interaction: Efficiently manage and query multiple distinct language models concurrently to synthesize comprehensive responses based on diverse model strengths.

• 🔐 Strict Access Governance (RBAC): Enforce security policies where only designated administrators retain rights for pulling models or creating new ones within the Ollama environment.

• 🌐🌍 Internationalization (i18n): The interface is localized, supporting multiple languages. Contributions to expand language support are actively encouraged!

• 🧩 Extensibility via Pipelines: Integrate custom operational logic and external Python modules through the Pipelines Plugin Framework. By directing the OpenAI URL to the Pipelines instance, users unlock advanced capabilities such as Function Calling, user Rate Limiting, Usage Monitoring (e.g., Langfuse integration), Real-time Translation (LibreTranslate), and Harmful Content Filtering.

• 🌟 Commitment to Evolution: We consistently deliver updates, bug resolutions, and feature enhancements for Open WebUI.

To get a detailed rundown of all functionalities, explore the Open WebUI documentation on features!

Explore the Open WebUI Ecosystem! 🔗

Don't overlook our affiliated project, Open WebUI Community, a repository for discovering and downloading pre-configured Modelfiles designed to augment your Open WebUI interactions! 🚀

Deployment Instructions 🚀

Installation via Python Package Manager (pip) 🐍

Open WebUI can be installed using the standard Python package manager. Python version 3.11 is required to ensure full compatibility.

1. Install the Package: Execute the following command in your terminal:

bash pip install open-webui

1. Launch the Service: Start the application server with:

bash open-webui serve

This action initiates the service, typically accessible at [http://localhost:8080]

Rapid Start with Docker 🐳

[!NOTE]
Depending on your Docker configuration, network adjustments may be necessary. Refer to the Open WebUI Documentation for resolving connection anomalies.

[!WARNING] When employing Docker, the volume mapping -v open-webui:/app/backend/data is mandatory to persist the application database and avoid data loss.

[!TIP] For setups requiring integrated Ollama or enabling GPU acceleration, use images explicitly tagged with :ollama or :cuda. Enabling CUDA necessitates the prior installation of the Nvidia CUDA container toolkit on the host system (Linux/WSL).

Standard Configuration Deployment

• For Local Ollama Instance:

bash 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

• For Remote Ollama Server:

Modify the OLLAMA_BASE_URL environment variable to point to the remote server:

bash 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

• For GPU-Accelerated Execution:

bash 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

Deployment for Exclusive OpenAI API Use

• If utilizing only the OpenAI API:

bash 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

Installation with Integrated Ollama Bundling

This method consolidates Open WebUI and the Ollama service into a single container image for simplified initial setup. Select the command appropriate for your hardware:

• With GPU Acceleration:

bash 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

• CPU-Only Mode:

bash 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

Both commands establish a self-contained environment running both components rapidly. Access the interface post-installation at [http://localhost:3000]. Enjoy! 😄

Alternative Installation Paths

We support various deployment strategies beyond standard Docker execution, including Docker Compose, Kustomize manifests, and Helm charts. Consult our Open WebUI Documentation on getting started or seek assistance on our Discord server.

Troubleshooting Common Issues

Facing connectivity problems? The Troubleshooting section in the documentation addresses common hurdles. For direct community support, join the Open WebUI Discord.

WebUI Container Connection Failure to Ollama

If the container cannot connect to the local Ollama service (expected at 127.0.0.1:11434 or host.docker.internal:11434), employing the --network=host flag often resolves this. Note that this changes the exposed port from 3000 to 8080, leading to access at http://localhost:8080.

Example Host Network Command:

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

Updating Docker Installations

To migrate your locally running Docker instance to the most current release, utilize Watchtower:

docker run --rm --volume /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once open-webui

If your container name differs from open-webui, substitute it in the final argument.

Review our Migration Guide within the Open WebUI Documentation for detailed upgrade procedures.

Experimenting with the Development Branch 🌙

[!WARNING] The :dev tag provides access to pre-release features which may contain bugs or incomplete functionality. Proceed with caution.

To test the latest unstable developments, use the :dev image tag:

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

Future Outlook 🌟

Explore planned enhancements and features detailed on our Open WebUI Roadmap.

Licensing Information 📜

This software is distributed under the terms of the MIT License (see the accompanying LICENSE file).

Community Support 💬

For inquiries, suggestions, or assistance, please submit a new issue or connect with the team and community via our Open WebUI Discord server. 🤝

Star Trajectory

---

Developed by Timothy Jaeryang Baek - Let's collaborate to advance Open WebUI! 💪

WIKIPEDIA CONTEXT: A headless browser functions without a visual display interface, offering automated control over web page interactions via command line or network protocols. They are invaluable for testing, screenshotting, and automating web interactions, mimicking full browser rendering including CSS and JavaScript execution. Modern browser versions (Chrome >= 59, Firefox >= 56) natively support this control, superseding tools like PhantomJS.

Primary Applications: Test automation for modern web apps, generating page captures, running JS library tests, and automating page interactions.

Secondary Uses: Web scraping (even for AJAX-heavy sites, as noted by Google in 2009). Potential for misuse (DDoS, ad fraud, credential stuffing) exists, though 2018 studies suggest no higher prevalence of malicious use compared to standard browsers.

Automation Tools Utilizing Headless Mode: Selenium WebDriver, Playwright (Chromium, Firefox, WebKit), Puppeteer (Chrome/Firefox). Frameworks like Capybara, Jasmine, and Cypress also leverage this capability for user simulation testing. Alternatives like Deno's built-in browser APIs or jsdom (Node.js) offer faster performance but lack DOM rendering.