Top Related Projects
A Gradio web UI for Large Language Models.
Stable Diffusion web UI
An open platform for training, serving, and evaluating large language models. Release repo for Vicuna and Chatbot Arena.
Build and share delightful machine learning apps, all in Python. 🌟 Star to support our work!
Integrate cutting-edge LLM technology quickly and easily into your apps
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Quick Overview
Open WebUI is an open-source, customizable, and feature-rich web interface for Large Language Models (LLMs). It provides a user-friendly platform for interacting with various LLMs, including local models and those from providers like OpenAI. The project aims to offer a comprehensive solution for deploying and managing LLM-powered applications.
Pros
- Highly customizable and extensible architecture
- Supports multiple LLM providers and local models
- User-friendly interface with advanced features like conversation management and model switching
- Active development and community support
Cons
- May require significant setup and configuration for advanced use cases
- Performance can vary depending on the underlying LLM and hardware
- Limited documentation for some advanced features
- Potential learning curve for users new to LLM applications
Getting Started
To get started with Open WebUI, follow these steps:
-
Clone the repository:
git clone https://github.com/open-webui/open-webui.git cd open-webui -
Install dependencies:
pip install -r requirements.txt -
Set up environment variables:
cp .env.example .env # Edit .env file with your configuration -
Run the application:
python main.py -
Access the web interface at
http://localhost:8080
For more detailed instructions and configuration options, refer to the project's documentation on GitHub.
Competitor Comparisons
A Gradio web UI for Large Language Models.
Pros of text-generation-webui
- More extensive model support, including various architectures and quantization methods
- Richer set of features for text generation, including chat, notebook, and instruct modes
- Active community with frequent updates and contributions
Cons of text-generation-webui
- More complex setup and configuration process
- Higher system requirements due to broader feature set
- Steeper learning curve for new users
Code Comparison
text-generation-webui:
def generate_reply(
question, state, stopping_strings=None, is_chat=False, for_ui=False
):
# Complex generation logic with multiple parameters and modes
# ...
open-webui:
async def generate(
self, prompt: str, max_new_tokens: int = 250, **kwargs
) -> AsyncGenerator[str, None]:
# Simpler generation function focused on streaming output
# ...
The code comparison highlights the difference in complexity between the two projects. text-generation-webui offers more advanced features and options, while open-webui focuses on a streamlined approach to text generation.
Stable Diffusion web UI
Pros of stable-diffusion-webui
- More mature and feature-rich, with a larger user base and extensive community support
- Offers a wider range of built-in models and extensions for image generation
- Provides advanced features like inpainting, outpainting, and img2img
Cons of stable-diffusion-webui
- Can be more complex to set up and configure, especially for beginners
- May have higher system requirements due to its extensive feature set
- UI can be overwhelming with numerous options and settings
Code Comparison
stable-diffusion-webui:
import modules.scripts
from modules import sd_samplers
from modules.processing import process_images, Processed
from modules.shared import opts, cmd_opts, state
open-webui:
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel
The code snippets show that stable-diffusion-webui is more focused on image processing modules, while open-webui appears to be a more general-purpose web application framework. This reflects the specialized nature of stable-diffusion-webui compared to the potentially broader application of open-webui.
An open platform for training, serving, and evaluating large language models. Release repo for Vicuna and Chatbot Arena.
Pros of FastChat
- More comprehensive and feature-rich, offering a wider range of functionalities for language model deployment and interaction
- Better suited for research and development purposes, with tools for model evaluation and benchmarking
- Supports a broader range of language models and architectures
Cons of FastChat
- More complex setup and configuration process compared to Open WebUI
- Steeper learning curve for users who are not familiar with machine learning frameworks
- Less focus on user interface and ease of use for non-technical users
Code Comparison
FastChat example (model loading):
from fastchat.model import load_model
model, tokenizer = load_model("vicuna-7b", device="cuda", num_gpus=1)
Open WebUI example (API interaction):
import requests
response = requests.post("http://localhost:8080/v1/chat/completions", json={
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": "Hello!"}]
})
While FastChat focuses on model implementation and deployment, Open WebUI emphasizes API interaction and user interface integration. FastChat provides more low-level control over model loading and processing, whereas Open WebUI offers a simpler API-centric approach for integrating language models into web applications.
Build and share delightful machine learning apps, all in Python. 🌟 Star to support our work!
Pros of Gradio
- More mature and widely adopted project with extensive documentation
- Supports a broader range of ML frameworks and use cases
- Easier to integrate into existing Python projects
Cons of Gradio
- Less focused on chat-specific interfaces
- Requires more coding to create complex, interactive UIs
- May have a steeper learning curve for non-developers
Code Comparison
Open-WebUI:
from openwebui import ChatUI
ui = ChatUI()
ui.add_message("Hello, how can I help you?", "assistant")
ui.run()
Gradio:
import gradio as gr
def chat(message, history):
return "Hello! How can I assist you today?"
gr.ChatInterface(chat).launch()
Summary
Gradio is a versatile tool for creating web interfaces for machine learning models, while Open-WebUI focuses specifically on chat interfaces. Gradio offers more flexibility and integration options but may require more setup for chat applications. Open-WebUI provides a simpler, more targeted solution for chat interfaces but with potentially less customization options.
Integrate cutting-edge LLM technology quickly and easily into your apps
Pros of Semantic Kernel
- More comprehensive framework for AI orchestration and integration
- Stronger support for enterprise-level applications and scalability
- Extensive documentation and community support
Cons of Semantic Kernel
- Steeper learning curve due to its complexity
- Primarily focused on C# and .NET ecosystem, potentially limiting for some developers
Code Comparison
Semantic Kernel (C#):
var kernel = Kernel.Builder.Build();
var function = kernel.CreateSemanticFunction("Generate a story about {{$input}}");
var result = await kernel.RunAsync("a brave knight", function);
Open WebUI (JavaScript):
const response = await fetch('/api/chat', {
method: 'POST',
body: JSON.stringify({ message: 'Generate a story about a brave knight' })
});
const result = await response.json();
Key Differences
- Semantic Kernel offers a more structured approach to AI integration, while Open WebUI focuses on providing a user interface for language models
- Open WebUI is more accessible for web developers, whereas Semantic Kernel caters to .NET developers
- Semantic Kernel provides more advanced features for AI orchestration, while Open WebUI emphasizes ease of use and quick deployment
Use Cases
- Semantic Kernel: Enterprise applications, complex AI integrations, .NET projects
- Open WebUI: Rapid prototyping, web-based chatbots, simple AI interfaces
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Pros of Transformers
- Extensive library of pre-trained models for various NLP tasks
- Well-documented and actively maintained by a large community
- Supports multiple deep learning frameworks (PyTorch, TensorFlow)
Cons of Transformers
- Steeper learning curve for beginners
- Requires more computational resources for training and inference
- Focused primarily on NLP tasks, less versatile for other domains
Code Comparison
Transformers:
from transformers import pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("I love this product!")[0]
print(f"Label: {result['label']}, Score: {result['score']:.4f}")
Open-WebUI:
// No direct code comparison available as Open-WebUI is a web interface
// for language models, not a programming library like Transformers
Additional Notes
Open-WebUI is a web-based user interface for interacting with language models, while Transformers is a library for working with pre-trained models in code. They serve different purposes and are not directly comparable in terms of functionality. Open-WebUI provides a user-friendly interface for non-technical users, while Transformers offers more flexibility and control for developers and researchers working with NLP models.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Open WebUI (Formerly Ollama WebUI) ð
Open WebUI is an extensible, feature-rich, and user-friendly self-hosted WebUI designed to operate entirely offline. It supports various LLM runners, including Ollama and OpenAI-compatible APIs. For more information, be sure to check out our Open WebUI Documentation.
Key Features of Open WebUI â
-
ð Effortless Setup: Install seamlessly using Docker or Kubernetes (kubectl, kustomize or helm) for a hassle-free experience with support for both
:ollamaand:cudatagged images. -
ð¤ Ollama/OpenAI API Integration: Effortlessly integrate OpenAI-compatible APIs for versatile conversations alongside Ollama models. Customize the OpenAI API URL to link with LMStudio, GroqCloud, Mistral, OpenRouter, and more.
-
𧩠Pipelines, Open WebUI Plugin Support: Seamlessly integrate custom logic and Python libraries into Open WebUI using Pipelines Plugin Framework. Launch your Pipelines instance, set the OpenAI URL to the Pipelines URL, and explore endless possibilities. Examples include Function Calling, User Rate Limiting to control access, Usage Monitoring with tools like Langfuse, Live Translation with LibreTranslate for multilingual support, Toxic Message Filtering and much more.
-
ð± Responsive Design: Enjoy a seamless experience across Desktop PC, Laptop, and Mobile devices.
-
ð± Progressive Web App (PWA) for Mobile: Enjoy a native app-like experience on your mobile device with our PWA, providing offline access on localhost and a seamless user interface.
-
âï¸ð¢ Full Markdown and LaTeX Support: Elevate your LLM experience with comprehensive Markdown and LaTeX capabilities for enriched interaction.
-
ð¤ð¹ Hands-Free Voice/Video Call: Experience seamless communication with integrated hands-free voice and video call features, allowing for a more dynamic and interactive chat environment.
-
ð ï¸ Model Builder: Easily create Ollama models via the Web UI. Create and add custom characters/agents, customize chat elements, and import models effortlessly through Open WebUI Community integration.
-
ð Native Python Function Calling Tool: Enhance your LLMs with built-in code editor support in the tools workspace. Bring Your Own Function (BYOF) by simply adding your pure Python functions, enabling seamless integration with LLMs.
-
ð Local RAG Integration: Dive into the future of chat interactions with groundbreaking Retrieval Augmented Generation (RAG) support. This feature seamlessly integrates document interactions into your chat experience. You can load documents directly into the chat or add files to your document library, effortlessly accessing them using the
#command before a query. -
ð Web Search for RAG: Perform web searches using providers like
SearXNG,Google PSE,Brave Search,serpstack,serper,Serply,DuckDuckGo,TavilySearchandSearchApiand inject the results directly into your chat experience. -
ð Web Browsing Capability: Seamlessly integrate websites into your chat experience using the
#command followed by a URL. This feature allows you to incorporate web content directly into your conversations, enhancing the richness and depth of your interactions. -
ð¨ Image Generation Integration: Seamlessly incorporate image generation capabilities using options such as AUTOMATIC1111 API or ComfyUI (local), and OpenAI's DALL-E (external), enriching your chat experience with dynamic visual content.
-
âï¸ Many Models Conversations: Effortlessly engage with various models simultaneously, harnessing their unique strengths for optimal responses. Enhance your experience by leveraging a diverse set of models in parallel.
-
ð Role-Based Access Control (RBAC): Ensure secure access with restricted permissions; only authorized individuals can access your Ollama, and exclusive model creation/pulling rights are reserved for administrators.
-
ðð Multilingual Support: Experience Open WebUI in your preferred language with our internationalization (i18n) support. Join us in expanding our supported languages! We're actively seeking contributors!
-
ð Continuous Updates: We are committed to improving Open WebUI with regular updates, fixes, and new features.
Want to learn more about Open WebUI's features? Check out our Open WebUI documentation for a comprehensive overview!
ð Also Check Out Open WebUI Community!
Don't forget to explore our sibling project, Open WebUI Community, where you can discover, download, and explore customized Modelfiles. Open WebUI Community offers a wide range of exciting possibilities for enhancing your chat interactions with Open WebUI! ð
How to Install ð
[!NOTE]
Please note that for certain Docker environments, additional configurations might be needed. If you encounter any connection issues, our detailed guide on Open WebUI Documentation is ready to assist you.
Quick Start with Docker ð³
[!WARNING] When using Docker to install Open WebUI, make sure to include the
-v open-webui:/app/backend/datain your Docker command. This step is crucial as it ensures your database is properly mounted and prevents any loss of data.
[!TIP]
If you wish to utilize Open WebUI with Ollama included or CUDA acceleration, we recommend utilizing our official images tagged with either:cudaor:ollama. To enable CUDA, you must install the Nvidia CUDA container toolkit on your Linux/WSL system.
Installation with Default Configuration
-
If Ollama is on your computer, use this command:
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 -
If Ollama is on a Different Server, use this command:
To connect to Ollama on another server, change the
OLLAMA_BASE_URLto the server's URL: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- To run Open WebUI with Nvidia GPU support, use this command:
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
Installation for OpenAI API Usage Only
-
If you're only using OpenAI API, use this command:
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
Installing Open WebUI with Bundled Ollama Support
This installation method uses a single container image that bundles Open WebUI with Ollama, allowing for a streamlined setup via a single command. Choose the appropriate command based on your hardware setup:
-
With GPU Support: Utilize GPU resources by running the following command:
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 -
For CPU Only: If you're not using a GPU, use this command instead:
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 facilitate a built-in, hassle-free installation of both Open WebUI and Ollama, ensuring that you can get everything up and running swiftly.
After installation, you can access Open WebUI at http://localhost:3000. Enjoy! ð
Other Installation Methods
We offer various installation alternatives, including non-Docker native installation methods, Docker Compose, Kustomize, and Helm. Visit our Open WebUI Documentation or join our Discord community for comprehensive guidance.
Troubleshooting
Encountering connection issues? Our Open WebUI Documentation has got you covered. For further assistance and to join our vibrant community, visit the Open WebUI Discord.
Open WebUI: Server Connection Error
If you're experiencing connection issues, itâs often due to the WebUI docker container not being able to reach the Ollama server at 127.0.0.1:11434 (host.docker.internal:11434) inside the container . Use the --network=host flag in your docker command to resolve this. Note that the port changes from 3000 to 8080, resulting in the link: http://localhost:8080.
Example Docker 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
Keeping Your Docker Installation Up-to-Date
In case you want to update your local Docker installation to the latest version, you can do it with Watchtower:
docker run --rm --volume /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once open-webui
In the last part of the command, replace open-webui with your container name if it is different.
Check our Migration Guide available in our Open WebUI Documentation.
Using the Dev Branch ð
[!WARNING] The
:devbranch contains the latest unstable features and changes. Use it at your own risk as it may have bugs or incomplete features.
If you want to try out the latest bleeding-edge features and are okay with occasional instability, you can use the :dev tag like this:
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
What's Next? ð
Discover upcoming features on our roadmap in the Open WebUI Documentation.
Supporters â¨
A big shoutout to our amazing supporters who's helping to make this project possible! ð
Platinum Sponsors ð¤
- We're looking for Sponsors!
Acknowledgments
Special thanks to Prof. Lawrence Kim and Prof. Nick Vincent for their invaluable support and guidance in shaping this project into a research endeavor. Grateful for your mentorship throughout the journey! ð
License ð
This project is licensed under the MIT License - see the LICENSE file for details. ð
Support ð¬
If you have any questions, suggestions, or need assistance, please open an issue or join our Open WebUI Discord community to connect with us! ð¤
Star History
Created by Timothy J. Baek - Let's make Open WebUI even more amazing together! ðª
Top Related Projects
A Gradio web UI for Large Language Models.
Stable Diffusion web UI
An open platform for training, serving, and evaluating large language models. Release repo for Vicuna and Chatbot Arena.
Build and share delightful machine learning apps, all in Python. 🌟 Star to support our work!
Integrate cutting-edge LLM technology quickly and easily into your apps
🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot