diff --git a/docs/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible.mdx b/docs/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible.mdx
index 954fa499..bc64c866 100644
--- a/docs/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible.mdx
+++ b/docs/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible.mdx
@@ -4,94 +4,301 @@ title: "OpenAI-Compatible"
---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
## Overview
-Open WebUI isn't just for OpenAI/Ollama/Llama.cpp—you can connect **any server that implements the OpenAI-compatible API**, running locally or remotely. This is perfect if you want to run different language models, or if you already have a favorite backend or ecosystem.
+Open WebUI connects to **any server or provider that implements the OpenAI-compatible API**. This guide covers how to set up connections for popular cloud providers and local servers.
+
+For OpenAI itself (or Azure OpenAI), see the dedicated **[OpenAI guide](/getting-started/quick-start/connect-a-provider/starting-with-openai)**.
---
## Protocol-Oriented Design
-Open WebUI is built around **Standard Protocols**. Instead of building specific modules for every individual AI provider (which leads to inconsistent behavior and configuration bloat), Open WebUI focuses on the **OpenAI Chat Completions Protocol**.
+Open WebUI is built around **Standard Protocols**. Instead of building specific modules for every individual AI provider, Open WebUI focuses on the **OpenAI Chat Completions Protocol**.
-This means that while Open WebUI handles the **interface and tools**, it expects your backend to follow the universal Chat Completions standard.
+- **We Support Protocols**: Any provider that follows widely adopted API standards is natively supported. We also have experimental support for **[Open Responses](https://www.openresponses.org/)**.
+- **We Avoid Proprietary APIs**: We do not implement provider-specific, non-standard APIs in the core to maintain a universal, maintainable codebase. For unsupported providers, use a [pipe](/features/extensibility/plugin/functions/pipe) or a middleware proxy like LiteLLM or OpenRouter to bridge them.
-- **We Support Protocols**: Any provider that follows widely adopted API standards (like Groq, OpenRouter, OpenAI, Mistral, Perplexity and many more) is natively supported. We also have experimental support for **[Open Responses](https://www.openresponses.org/)**.
-- **We Avoid Proprietary APIs**: We do not implement provider-specific, non-standard APIs in the core to maintain a universal, maintainable codebase. For unsupported providers, use a pipe or middleware proxy.
-
-If you are using a provider that requires a proprietary API, we recommend using a **[pipe](/features/extensibility/plugin/functions/pipe)** (browse [community pipes](https://openwebui.com/)) or a middleware proxy like LiteLLM or OpenRouter to bridge them to a supported protocol.
-
-For a detailed explanation of why we've made this architectural decision, see our **[FAQ: Why doesn't Open WebUI natively support proprietary APIs?](/faq#q-why-doesnt-open-webui-natively-support-provider-xs-proprietary-api)**
-
-### Popular Compatible Servers and Providers
-
-There are many servers and tools that expose an OpenAI-compatible API. Pick whichever suits your workflow:
-
-- **Local Runners**: [Ollama](https://ollama.com/), [Llama.cpp](https://github.com/ggml-org/llama.cpp), [LM Studio](https://lmstudio.ai/), [vLLM](https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html), [LocalAI](https://localai.io/), [Lemonade](https://lemonade-server.ai/), [Docker Model Runner](https://docs.docker.com/ai/model-runner/).
-- **Cloud Providers**: [Groq](https://groq.com/), [Mistral AI](https://mistral.ai/), [Perplexity](https://www.perplexity.ai/), [MiniMax](https://platform.minimax.io/), [DeepSeek](https://platform.deepseek.com/), [OpenRouter](https://openrouter.ai/), [LiteLLM](https://docs.litellm.ai/).
-- **Major Model Ecosystems**:
- - **Google Gemini**: [OpenAI Endpoint](https://generativelanguage.googleapis.com/v1beta/openai/) (requires a Gemini API key).
- - **Anthropic**: While they primarily use a proprietary API, they offer a [Chat Completions compatible endpoint](https://platform.claude.com/docs/en/api/openai-sdk) for easier integration.
- - **Azure OpenAI**: Enterprise-grade OpenAI hosting via Microsoft Azure.
+For a detailed explanation of this architectural decision, see our **[FAQ on protocol support](/faq#q-why-doesnt-open-webui-natively-support-provider-xs-proprietary-api)**.
---
-## Step 1: Connect Your Server to Open WebUI
+:::warning Important: Connection Verification May Fail for Some Providers
-#### 🍋 Get Started with Lemonade
+When you add a connection, Open WebUI verifies it by calling the provider's `/models` endpoint using a standard `Bearer` token. **Some providers do not implement the `/models` endpoint** or use non-standard authentication for it. In these cases:
-Lemonade is a plug-and-play ONNX-based OpenAI-compatible server. Here’s how to try it on Windows:
+- The connection verification will **fail with an error** (e.g., 401 or 403).
+- This does **not** mean the provider is incompatible — **chat completions will still work**.
+- You just need to **manually add model names** to the **Model IDs (Filter)** allowlist in the connection settings.
-1. [Download the latest `.exe`](https://github.com/lemonade-sdk/lemonade/releases)
-2. Run `Lemonade_Server_Installer.exe`
-3. Install and download a model using Lemonade’s installer
-4. Once running, your API endpoint will be:
+**Providers with known `/models` issues:**
- ```
- http://localhost:8000/api/v1
- ```
+| Provider | `/models` works? | Action Needed |
+|---|---|---|
+| Anthropic | No — uses non-standard auth headers | Add model IDs manually (e.g., `claude-sonnet-4-5-20250514`) |
+| Perplexity | No — endpoint doesn't exist | Add model IDs manually (e.g., `sonar-pro`, `sonar-reasoning-pro`) |
+| MiniMax | No — endpoint doesn't exist | Add model IDs manually (e.g., `MiniMax-M2.5`) |
+| OpenRouter | Yes — but returns thousands of models | Strongly recommend adding a filtered allowlist |
+| Google Gemini | Yes | Auto-detection works |
+| DeepSeek | Yes | Auto-detection works |
+| Mistral | Yes | Auto-detection works |
+| Groq | Yes | Auto-detection works |
-
+**How to add models manually**: In the connection settings, find **Model IDs (Filter)**, type the model ID, and click the **+** icon. The models will then appear in your model selector even though the connection verification showed an error.
-See [their docs](https://lemonade-server.ai/docs/server/apps/open-webui/) for details.
+:::
---
-## Step 2: Connect Your Server to Open WebUI
+## Step 1: Add Your Provider Connection
1. Open Open WebUI in your browser.
2. Go to ⚙️ **Admin Settings** → **Connections** → **OpenAI**.
3. Click ➕ **Add Connection**.
-4. Select the **Standard / Compatible** tab (if available).
-5. Fill in the following:
- - **API URL**: Use your server’s API endpoint.
- * **Examples**: `http://localhost:11434/v1` (Ollama), `http://localhost:10000/v1` (Llama.cpp).
- - **API Key**: Leave blank unless the server requires one.
+4. Fill in the **URL** and **API Key** for your provider (see tabs below).
+5. If your provider doesn't support `/models` auto-detection, add your model IDs to the **Model IDs (Filter)** allowlist.
6. Click **Save**.
+:::tip
+If running Open WebUI in Docker and your model server is on the host machine, replace `localhost` with `host.docker.internal` in the URL.
+:::
+
+### Cloud Providers
+
+
+
+
+ **Anthropic** (Claude) offers an OpenAI-compatible endpoint. Note that this is intended for testing and comparison — for production use with full Claude features (PDF processing, citations, extended thinking, prompt caching), Anthropic recommends their native API.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.anthropic.com/v1` |
+ | **API Key** | Your Anthropic API key from [console.anthropic.com](https://console.anthropic.com/) |
+ | **Model IDs** | **Required** — add manually (e.g., `claude-sonnet-4-5-20250514`, `claude-opus-4-0-20250514`) |
+
+ :::caution
+ The `/models` endpoint **will fail** for Anthropic because their API uses non-standard authentication headers (`x-api-key` instead of `Bearer`). This is a cosmetic issue — **chat completions will work correctly**. Just add your model IDs to the allowlist manually.
+ :::
+
+
+
+
+ **Google Gemini** provides an OpenAI-compatible endpoint that works well with Open WebUI.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://generativelanguage.googleapis.com/v1beta/openai` |
+ | **API Key** | Your Gemini API key from [aistudio.google.com](https://aistudio.google.com/apikey) |
+ | **Model IDs** | Auto-detected — leave empty or filter to specific models |
+
+ :::warning No trailing slash
+ The URL must be exactly `https://generativelanguage.googleapis.com/v1beta/openai` — **without** a trailing slash. A trailing slash will break the `/models` endpoint call.
+ :::
+
+
+
+
+ **DeepSeek** is fully OpenAI-compatible with working `/models` auto-detection.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.deepseek.com/v1` |
+ | **API Key** | Your API key from [platform.deepseek.com](https://platform.deepseek.com/) |
+ | **Model IDs** | Auto-detected (e.g., `deepseek-chat`, `deepseek-reasoner`) |
+
+
+
+
+ **Mistral AI** is fully OpenAI-compatible with working `/models` auto-detection.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.mistral.ai/v1` |
+ | **API Key** | Your API key from [console.mistral.ai](https://console.mistral.ai/) |
+ | **Model IDs** | Auto-detected (e.g., `mistral-large-latest`, `codestral-latest`, `mistral-small-latest`) |
+
+
+
+
+ **Groq** provides extremely fast inference via an OpenAI-compatible API.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.groq.com/openai/v1` |
+ | **API Key** | Your API key from [console.groq.com](https://console.groq.com/) |
+ | **Model IDs** | Auto-detected (e.g., `llama-3.3-70b-versatile`, `deepseek-r1-distill-llama-70b`) |
+
+
+
+
+ **Perplexity** offers search-augmented AI models via an OpenAI-compatible chat completions endpoint.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.perplexity.ai` |
+ | **API Key** | Your API key from [perplexity.ai/settings](https://www.perplexity.ai/settings) (under API tab) |
+ | **Model IDs** | **Required** — add manually (e.g., `sonar-pro`, `sonar-reasoning-pro`, `sonar-deep-research`) |
+
+ :::caution
+ Perplexity does **not** have a `/models` endpoint. You must manually add model IDs to the allowlist. Some Perplexity models may also reject certain parameters like `stop` or `frequency_penalty`.
+ :::
+
+
+
+
+ **MiniMax** offers high-performance coding-focused models. Their **Coding Plan** subscription is cost-effective for high-frequency programming use.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://api.minimax.io/v1` |
+ | **API Key** | Your API key from [platform.minimax.io](https://platform.minimax.io/) |
+ | **Model IDs** | **Required** — add manually (e.g., `MiniMax-M2.5`) |
+
+ **Getting started with MiniMax:**
+
+ 1. Visit the [MiniMax Coding Plan](https://platform.minimax.io/subscribe/coding-plan) page and choose a plan.
+ 2. Go to [Account > Coding Plan](https://platform.minimax.io/user-center/payment/coding-plan) and click **Reset & Copy** to get your API key.
+ 3. Note: The Coding Plan API key is separate from the standard pay-as-you-go key.
+
+ :::caution
+ MiniMax does **not** expose a `/models` endpoint. You **must** add `MiniMax-M2.5` (or your desired model) to the **Model IDs (Filter)** allowlist for it to appear in the UI.
+ :::
+
+
+
+
+ **OpenRouter** aggregates hundreds of models from multiple providers behind a single API.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `https://openrouter.ai/api/v1` |
+ | **API Key** | Your API key from [openrouter.ai/keys](https://openrouter.ai/keys) |
+ | **Model IDs** | **Strongly recommended** — add a filtered allowlist |
+
+ :::tip
+ OpenRouter exposes **thousands of models**, which will clutter your model selector and slow down the admin panel. We **strongly recommend**:
+ 1. **Use an allowlist** — add only the specific model IDs you need (e.g., `anthropic/claude-sonnet-4-5`, `google/gemini-2.5-pro`).
+ 2. **Enable model caching** via `Settings > Connections > Cache Base Model List` or `ENABLE_BASE_MODELS_CACHE=True`. Without caching, page loads can take 10-15+ seconds. See the [Performance Guide](/troubleshooting/performance) for more details.
+ :::
+
+
+
+
+ **Amazon Bedrock** provides access to foundation models from multiple providers (Anthropic, Meta, Mistral, Amazon, etc.) through AWS. Bedrock does **not** natively expose an OpenAI-compatible API, so you need to run the **Bedrock Access Gateway (BAG)** — a middleware proxy that translates OpenAI API calls to Bedrock SDK calls.
+
+ **Prerequisites:**
+ - An active AWS account with Bedrock model access enabled ([Model Access docs](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access-modify.html))
+ - AWS Access Key and Secret Key with Bedrock IAM permissions
+ - Docker installed
+
+ **Step 1: Set up the Bedrock Access Gateway**
+
+ ```bash
+ git clone https://github.com/aws-samples/bedrock-access-gateway
+ cd bedrock-access-gateway
+ # Use the ECS Dockerfile
+ mv Dockerfile_ecs Dockerfile
+ docker build . -f Dockerfile -t bedrock-gateway
+ docker run -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID \
+ -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY \
+ -e AWS_REGION=us-east-1 \
+ -d -p 8000:80 bedrock-gateway
+ ```
+
+ Verify the gateway is running at `http://localhost:8000/docs`.
+
+ :::warning
+ If the container exits immediately, you may need to change `python:3.13-slim` to `python:3.12-slim` in the Dockerfile due to a Python 3.13 compatibility issue.
+ :::
+
+ **Step 2: Add the connection in Open WebUI**
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://host.docker.internal:8000/api/v1` |
+ | **API Key** | `bedrock` (default BAG key — change via `DEFAULT_API_KEYS` in BAG config) |
+ | **Model IDs** | Auto-detected from your enabled Bedrock models |
+
+
+
+
+### Local Servers
+
+
+
+
+ **Lemonade** is a plug-and-play ONNX-based OpenAI-compatible server for Windows.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://localhost:8000/api/v1` |
+ | **API Key** | Leave blank |
+
+ **Quick setup:** [Download the installer](https://github.com/lemonade-sdk/lemonade/releases), run it, install a model, and it will be available at the URL above. See [their docs](https://lemonade-server.ai/docs/server/apps/open-webui/) for details.
+
+
+
+
+ **LM Studio** provides a local OpenAI-compatible server with a GUI for model management.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://localhost:1234/v1` |
+ | **API Key** | Leave blank (or `lm-studio` as placeholder) |
+
+ Start the server in LM Studio via the "Local Server" tab before connecting.
+
+
+
+
+ **vLLM** is a high-throughput inference engine with an OpenAI-compatible server. See the dedicated **[vLLM guide](/getting-started/quick-start/connect-a-provider/starting-with-vllm)** for full setup instructions.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://localhost:8000/v1` (default vLLM port) |
+ | **API Key** | Leave blank (unless configured) |
+
+
+
+
+ **LocalAI** is a drop-in OpenAI-compatible replacement that runs models locally.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://localhost:8080/v1` |
+ | **API Key** | Leave blank |
+
+
+
+
+ **Docker Model Runner** runs AI models directly in Docker containers.
+
+ | Setting | Value |
+ |---|---|
+ | **URL** | `http://localhost:12434/engines/llama.cpp/v1` |
+ | **API Key** | Leave blank |
+
+ See the [Docker Model Runner docs](https://docs.docker.com/ai/model-runner/) for setup instructions.
+
+
+
+
:::tip Connection Timeout Configuration
-If your local server is slow to start or you're connecting over a high-latency network, you can adjust the model list fetch timeout:
+If your server is slow to start or you're connecting over a high-latency network, you can adjust the model list fetch timeout:
```bash
# Adjust timeout for slower connections (default is 10 seconds)
-AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST=5
+AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST=15
```
If you've saved an unreachable URL and the UI becomes unresponsive, see the [Model List Loading Issues](/troubleshooting/connection-error#️-model-list-loading-issues-slow-ui--unreachable-endpoints) troubleshooting guide for recovery options.
:::
-:::tip
-
-If running Open WebUI in Docker and your model server on your host machine, use `http://host.docker.internal:/v1`.
-
-:::
-
-##### **For Lemonade:** When adding Lemonade, use `http://localhost:8000/api/v1` as the URL.
-
-
-
---
## Required API Endpoints
@@ -100,7 +307,7 @@ To ensure full compatibility with Open WebUI, your server should implement the f
| Endpoint | Method | Required? | Purpose |
| :--- | :--- | :--- | :--- |
-| `/v1/models` | `GET` | **Yes** | Used for model discovery and selecting models in the UI. |
+| `/v1/models` | `GET` | Recommended | Used for model discovery and selecting models in the UI. If not available, add models to the allowlist manually. |
| `/v1/chat/completions` | `POST` | **Yes** | The core endpoint for chat, supporting streaming and parameters like temperature. |
| `/v1/embeddings` | `POST` | No | Required if you want to use this provider for RAG (Retrieval Augmented Generation). |
| `/v1/audio/speech` | `POST` | No | Required for Text-to-Speech (TTS) functionality. |
@@ -113,12 +320,12 @@ Open WebUI passes standard OpenAI parameters such as `temperature`, `top_p`, `ma
---
-## Step 3: Start Chatting!
+## Step 2: Start Chatting!
-Select your connected server’s model in the chat menu and get started!
+Select your connected provider's model in the chat menu and get started!
-That’s it! Whether you choose Llama.cpp, Ollama, LM Studio, or Lemonade, you can easily experiment and manage multiple model servers—all in Open WebUI.
+That's it! Whether you choose a cloud provider or a local server, you can manage multiple connections — all from within Open WebUI.
---
-🚀 Enjoy building your perfect local AI setup!
\ No newline at end of file
+🚀 Enjoy building your perfect AI setup!
diff --git a/docs/getting-started/quick-start/connect-a-provider/starting-with-openai.mdx b/docs/getting-started/quick-start/connect-a-provider/starting-with-openai.mdx
index 9a44eccc..3b838299 100644
--- a/docs/getting-started/quick-start/connect-a-provider/starting-with-openai.mdx
+++ b/docs/getting-started/quick-start/connect-a-provider/starting-with-openai.mdx
@@ -6,38 +6,30 @@ title: "OpenAI"
## Overview
-Open WebUI makes it easy to connect and use OpenAI and other OpenAI-compatible APIs. This guide will walk you through adding your API key, setting the correct endpoint, and selecting models — so you can start chatting right away.
+Open WebUI makes it easy to connect to **OpenAI** and **Azure OpenAI**. This guide will walk you through adding your API key, setting the correct endpoint, and selecting models — so you can start chatting right away.
+
+For other providers that offer an OpenAI-compatible API (Anthropic, Google Gemini, Mistral, Groq, DeepSeek, and many more), see the **[OpenAI-Compatible Providers](/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible)** guide.
---
## Important: Protocols, Not Providers
-Open WebUI is a **protocol-centric** platform. While we provide first-class support for OpenAI models, we do so mainly through the **OpenAI Chat Completions API protocol**.
+Open WebUI is a **protocol-centric** platform. While we provide first-class support for OpenAI models, we do so mainly through the **OpenAI Chat Completions API protocol**.
We focus on universal standards shared across dozens of providers, with experimental support for emerging standards like **[Open Responses](https://www.openresponses.org/)**. For a detailed explanation, see our **[FAQ on protocol support](/faq#q-why-doesnt-open-webui-natively-support-provider-xs-proprietary-api)**.
---
-## Step 1: Get Your OpenAI API Key
-
-To use OpenAI models (such as GPT-4 or o3-mini), you need an API key from a supported provider.
-
-You can use:
-
-- **OpenAI** directly (https://platform.openai.com/account/api-keys)
-- **Azure OpenAI**
-- **Anthropic** (via their [OpenAI-compatible endpoint](https://platform.claude.com/docs/en/api/openai-sdk))
-- **Google Gemini** (via their [OpenAI-compatible endpoint](https://generativelanguage.googleapis.com/v1beta/openai/))
-- **DeepSeek** (https://platform.deepseek.com/)
-- **MiniMax** (https://platform.minimax.io/)
-- **Proxies & Aggregators**: OpenRouter, LiteLLM, Helicone, Vercel AI Gateway.
-- **Local Servers**: Ollama, Llama.cpp, LM Studio, vLLM, LocalAI.
-
----
-
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
+## Step 1: Get Your OpenAI API Key
+
+- **OpenAI**: Get your key at [platform.openai.com/account/api-keys](https://platform.openai.com/account/api-keys)
+- **Azure OpenAI**: Get your key from the [Azure Portal](https://portal.azure.com/)
+
+---
+
## Step 2: Add the API Connection in Open WebUI
Once Open WebUI is running:
@@ -47,13 +39,11 @@ Once Open WebUI is running:
3. Click ➕ **Add New Connection**.
-
-
- Use this for **OpenAI**, **DeepSeek**, **MiniMax**, **OpenRouter**, **LocalAI**, **FastChat**, **Helicone**, **LiteLLM**, **Vercel AI Gateway** etc.
+
* **Connection Type**: External
- * **URL**: `https://api.openai.com/v1` (or your provider's endpoint)
- * **API Key**: Your secret key (usually starts with `sk-...`)
+ * **URL**: `https://api.openai.com/v1`
+ * **API Key**: Your secret key (starts with `sk-...`)
@@ -74,17 +64,7 @@ Once Open WebUI is running:
* **Model IDs (Filter)**:
* *Default (Empty)*: Auto-detects all available models from the provider.
* *Set*: Acts as an **Allowlist**. Only the specific model IDs you enter here will be visible to users. Use this to hide older or expensive models.
-
- :::tip OpenRouter Recommendation
- When using **OpenRouter**, we **highly recommend**:
- 1. **Use an allowlist** (add specific Model IDs). OpenRouter exposes thousands of models, which can clutter your model selector and slow down the admin panel if not filtered.
- 2. **Enable Model Caching** (`Settings > Connections > Cache Base Model List` or `ENABLE_BASE_MODELS_CACHE=True`). Without caching, page loads can take 10-15+ seconds on first visit due to querying a large number of models. See the [Performance Guide](/troubleshooting/performance) for more details.
- :::
- :::caution MiniMax Whitelisting
- Some providers, like **MiniMax**, do not expose their models via a `/models` endpoint. For these providers, you **must** manually add the Model ID (e.g., `MiniMax-M2.5`) to the **Model IDs (Filter)** list for them to appear in the UI.
- :::
-
* **Prefix ID**:
* If you connect multiple providers that have models with the same name (e.g., two providers both offering `llama3`), add a prefix here (e.g., `groq/`) to distinguish them. The model will appear as `groq/llama3`.
@@ -113,9 +93,9 @@ If you've saved an unreachable URL and the UI becomes unresponsive, see the [Mod
Once your connection is saved, you can start using models right inside Open WebUI.
-🧠 You don’t need to download any models — just select one from the Model Selector and start chatting. If a model is supported by your provider, you’ll be able to use it instantly via their API.
+🧠 You don't need to download any models — just select one from the Model Selector and start chatting. If a model is supported by your provider, you'll be able to use it instantly via their API.
-Here’s what model selection looks like:
+Here's what model selection looks like:
@@ -125,9 +105,9 @@ Simply choose GPT-4, o3-mini, or any compatible model offered by your provider.
## All Set!
-That’s it! Your OpenAI-compatible API connection is ready to use.
+That's it! Your OpenAI API connection is ready to use.
-With Open WebUI and OpenAI, you get powerful language models, an intuitive interface, and instant access to chat capabilities — no setup headaches.
+If you want to connect other providers (Anthropic, Google Gemini, Mistral, Groq, DeepSeek, etc.), see the **[OpenAI-Compatible Providers](/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible)** guide.
If you run into issues or need additional support, visit our [help section](/troubleshooting).
diff --git a/docs/tutorials/integrations/llm-providers/amazon-bedrock.md b/docs/tutorials/integrations/llm-providers/amazon-bedrock.md
deleted file mode 100644
index c5d3ce48..00000000
--- a/docs/tutorials/integrations/llm-providers/amazon-bedrock.md
+++ /dev/null
@@ -1,118 +0,0 @@
----
-sidebar_position: 31
-title: "Integrate with Amazon Bedrock"
----
-
-:::warning
-
-This tutorial is a community contribution and is not supported by the Open WebUI team. It serves only as a demonstration on how to customize Open WebUI for your specific use case. Want to contribute? Check out the contributing tutorial.
-
-:::
-
----
-
-# Integrating Open-WebUI with Amazon Bedrock
-
-In this tutorial, we'll explore one of the most common and popular approaches to integrate Open-WebUI with Amazon Bedrock.
-
-## Prerequisites
-
-In order to follow this tutorial, you must have the following:
-
-- An active AWS account
-- An active AWS Access Key and Secret Key
-- IAM permissions in AWS to enable Bedrock models or already enabled models
-- Docker installed on your system
-
-## What is Amazon Bedrock
-
-Direct from AWS' website:
-
-"Amazon Bedrock is a fully managed service that offers a choice of high-performing foundation models (FMs) from leading AI companies like AI21 Labs, Anthropic, Cohere, Luma, Meta, Mistral AI, poolside (coming soon), Stability AI, and Amazon through a single API, along with a broad set of capabilities you need to build generative AI applications with security, privacy, and responsible AI. Using Amazon Bedrock, you can easily experiment with and evaluate top FMs for your use case, privately customize them with your data using techniques such as fine-tuning and Retrieval Augmented Generation (RAG), and build agents that execute tasks using your enterprise systems and data sources. Since Amazon Bedrock is serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy generative AI capabilities into your applications using the AWS services you are already familiar with."
-
-To learn more about Bedrock, visit: [Amazon Bedrock's Official Page](https://aws.amazon.com/bedrock/)
-
-# Integration Steps
-
-## Step 1: Verify access to Amazon Bedrock Base Models
-
-Before we can integrate with Bedrock, you first have to verify that you have access to at least one, but preferably many, of the available Base Models. At the time of this writing (Feb 2025), there were 47 base models available. You can see in the screenshot below that I have access to multiple models. You'll know if you have access to a model if it says "✅ Access Granted" next to the model. If you don't have access to any models, you will get an error on the next step.
-
-AWS provides good documentation for request accessing / enabling these models in the [Amazon Bedrock's Model Access Docs](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access-modify.html)
-
-
-
-## Step 2: Configure the Bedrock Access Gateway
-
-Now that we have access to at least one Bedrock base model, we need to configure the Bedrock Access Gateway, or BAG. You can think of the BAG as kind of proxy or middleware developed by AWS that wraps around AWS native endpoints/SDK for Bedrock and, in turn, exposes endpoints that are compatible with OpenAI's schema, which is what Open-WebUI requires.
-
-For reference, here is a simple mapping between the endpoints:
-
-| OpenAI Endpoint | Bedrock Method |
-|-----------------------|------------------------|
-| `/models` | list_inference_profiles |
-| `/models/{model_id}` | list_inference_profiles |
-| `/chat/completions` | converse or converse_stream |
-| `/embeddings` | invoke_model |
-
-The BAG repo can be found in the [Bedrock Access Gateway Repo](https://github.com/aws-samples/bedrock-access-gateway)
-
-To set-up the BAG, follow the below steps:
-
-- Clone the BAG repo
-- Remove the default `dockerfile`
-- Change the name of the `Dockerfile_ecs` to `Dockerfile`
-
-We're now ready to build and launch the docker container using:
-
-```bash
-docker build . -f Dockerfile -t bedrock-gateway
-
-docker run -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY -e AWS_SESSION_TOKEN=$AWS_SESSION_TOKEN -e AWS_REGION=us-east-1 -d -p 8000:80 bedrock-gateway
-```
-
-You should now be able to access the BAG's swagger page at: http://localhost:8000/docs
-
-:::warning Troubleshooting: Container Exits Immediately
-
-If the Bedrock Gateway container starts and immediately exits (especially on Windows), check the logs with `docker logs `. If you see Python/Uvicorn errors, this is likely a **Python 3.13 compatibility issue** with the BAG's Dockerfile.
-
-**Workaround:** Edit the `Dockerfile` before building and change the Python version from 3.13 to 3.12:
-
-```dockerfile
-# Change this line:
-FROM python:3.13-slim
-# To:
-FROM python:3.12-slim
-```
-
-Then rebuild with `docker build . -f Dockerfile -t bedrock-gateway`.
-
-:::
-
-
-
-## Step 3: Add Connection in Open-WebUI
-
-Now that you the BAG up-and-running, it's time to add it as a new connection in Open-WebUI.
-
-- Under the Admin Panel, go to Settings -> Connections.
-- Use the "+" (plus) button to add a new connection under the OpenAI
-- For the URL, use "http://host.docker.internal:8000/api/v1"
-- For the password, the default password defined in BAG is "bedrock". You can always change this password in the BAG settings (see DEFAULT_API_KEYS)
-- Click the "Verify Connection" button and you should see "Server connection verified" alert in the top-right
-
-
-
-## Step 4: Start using Bedrock Base Models
-
-You should now see all your Bedrock models available!
-
-
-
-## Other Helpful Tutorials
-
-These are a few other very helpful tutorials when working to integrate Open-WebUI with Amazon Bedrock.
-
-- https://gauravve.medium.com/connecting-open-webui-to-aws-bedrock-a1f0082c8cb2
-- https://jrpospos.blog/posts/2024/08/using-amazon-bedrock-with-openwebui-when-working-with-sensitive-data/
diff --git a/docs/tutorials/integrations/llm-providers/minimax.md b/docs/tutorials/integrations/llm-providers/minimax.md
deleted file mode 100644
index 870e9996..00000000
--- a/docs/tutorials/integrations/llm-providers/minimax.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-sidebar_position: 32
-title: "Integrate with MiniMax M2.5"
----
-
-:::warning
-
-This tutorial is a community contribution and is not supported by the Open WebUI team. It serves only as a demonstration on how to customize Open WebUI for your specific use case.
-
-:::
-
----
-
-# Integrating Open WebUI with MiniMax M2.5
-
-MiniMax is a leading AI company providing high-performance coding-focused models. Their latest model, **MiniMax M2.5**, is specifically optimized for coding, reasoning, and multi-turn dialogue. This guide covers how to set up MiniMax via their cost-effective **Coding Plan** and integrate it into Open WebUI.
-
-## Step 1: Subscribe to a MiniMax Coding Plan
-
-MiniMax offers a "Coding Plan" subscription which is significantly more cost-effective for high-frequency programming than standard pay-as-you-go models.
-
-1. Visit the [MiniMax Coding Plan Subscription page](https://platform.minimax.io/subscribe/coding-plan).
-2. Choose a plan that fits your needs (e.g., the **Starter** plan for $10/month).
-3. Complete the subscription process.
-
-:::info
-
-The **Starter** plan provides 100 "prompts" every 5 hours. One prompt is roughly equivalent to 15 requests, offering substantial value compared to token-based billing.
-
-:::
-
-Source: [MiniMax Coding Plan Official Documentation](https://platform.minimax.io/docs/coding-plan/intro)
-
-## Step 2: Obtain Your Coding Plan API Key
-
-Once subscribed, you need your specialized API Key.
-
-1. Navigate to the [Account/Coding Plan page](https://platform.minimax.io/user-center/payment/coding-plan).
-2. Click on **Reset & Copy** to generate and copy your API Key.
-3. Safely store this key in a password manager.
-
-
-
-:::info
-
-This API Key is exclusive to the Coding Plan and is not interchangeable with standard pay-as-you-go API Keys.
-
-:::
-
-## Step 3: Configure Connection in Open WebUI
-
-Now, link MiniMax to your Open WebUI instance.
-
-1. Open Open WebUI and navigate to the **Admin Panel** > **Settings** > **Connections**.
-2. Click the **+** (plus) icon under the **OpenAI API** section.
-3. Enter the following details:
- - **API Base URL**: `https://api.minimax.io/v1`
- - **API Key**: `YOUR_CODING_PLAN_API_KEY`
-4. **Important**: MiniMax does not expose models via a `/models` endpoint, so you must whitelist the model manually.
-5. In the **Model Whitelist**, type `MiniMax-M2.5` and click the **+** icon.
-6. Click **Verify Connection** (you should see a success alert).
-7. Click **Save** on the connection popup, then scroll down and click **Save** on the main Connections page.
-
-
-
-
-## Step 4: Start Chatting
-
-You are now ready to use MiniMax M2.5!
-
-1. Start a new chat.
-2. Select **MiniMax-M2.5** from the model dropdown menu.
-3. Send a message. Reasoning and thinking work by default without any additional configuration.
-
-
-
----
-
-Enjoy using one of the best and most affordable coding-focused models! 🚀
-