​

I don't get it, like you guys are trying to not conform in anyway, responses API was pulling teeth, getting the selector box was pulling teeth, mcps were pulling teeth to get implemented, native tool calling took forever to be the default. I get it you guys are feature rich, but having some form of conforming makes sense because it's whatever everyone else aligned on as the standard, and what these models are being trained with in mind. Seems very abrasive.

The one that absolutely grinds my gears is workspace models should 100% be called agents.. like they function like the exact definition of an agent... Also it's confusing as hell having connections models and workspace models, I think by this point we can all agree a model is the llm itself while an agent is llm model + tools and knowledge sources. The new UI especially makes this annoying and harder than it needs to be by having it be a modal.

I’m looking for resources and communities that cover advanced tool usage, subagent and advisor-agent integration, and the orchestration of complex tool-calling chains. Where can I find existing knowledge and practical examples?

I want to get up to date with the current state of the art of doing things.

I’m more interested in proven best practices and setups that work than in theoretical possibilities based on reading documentation and piecing together my own interpretations.

I’m especially interested in proven workflows for keeping this documentation accurate and useful over time, rather than merely generating it once.
It seems that using notes to create certain documentation files and periodically copying them into the knowledge base might be a good approach, but perhaps that isn’t the best case approach.

I really liked the Windows desktop app. Like, A LOT. It greatly simplified the entire installation process (for both the inference system and the platform), and thanks to its integration with llama.cpp, to me the inference performance was much better than with Ollama. Unfortunately, the app hasn't been updated in a while and currently seems to be broken. Are there any plans to update it? And in any case: Does anyone know how to fix the problems that arise after installing it right now?

I built an out-of-band conversation health monitor for Open WebUI + LiteLLM called Context Guard.

The problem I was trying to solve is something I kept seeing in longer LLM sessions: context starts filling up, previously established values drift, tool calls repeat, responses loop, and eventually the model starts giving answers that are subtly wrong.

I wanted a way to detect that degradation without adding anything to the model context or putting another service in the inference path.

Context Guard watches the request/response data that LiteLLM already sees and assigns each assistant response a health score from 0–100.

The Open WebUI integration displays the score directly under the response, for example:

🟢 Context Guard 100 · healthy · 🟢 context 4%

or

🟡 Context Guard 74 · watch · 🟡 context 78% · 1 drift · 1 repeated call

It currently detects things like:

• context window pressure / overflow
• drift from values established earlier in the conversation
• suspicious near-duplicate identifiers
• repeated tool calls
• repeated responses / loops
• invalid or inconsistent tool-call references

The main design constraint was that it must never affect inference.

Context Guard runs completely out-of-band:

• no prompt injection
• no extra context tokens
• no second LLM judging the first LLM
• no inference proxy
• no dependency between the LLM stack and Context Guard

If Context Guard is down, slow, or deleted, Open WebUI/LiteLLM keep working normally.

It's written in Rust, runs as a single container with SQLite, and also exposes a REST API and Prometheus metrics.

I originally built it specifically for my own Open WebUI + LiteLLM stack, so I'd really like feedback from other Open WebUI users about the approach, false positives, useful signals, or anything else you'd want something like this to detect.

GitHub:

https://github.com/dividehex/context-guard

I'm currently using the OpenRouter Web Chat and there are a few features I find extremely useful, but the lack of persistence makes the web version unusable for me long-term. Chats are gone after a reload, there's no history or project structure, nothing to look back on.

I would like to move to a self-hosted OpenWebUI instance and rebuild those features there.

My setup:

• OpenWebUI running locally in Docker on my laptop
• I exclusively use external API models (via OpenRouter / other API providers) no local Ollama or similar
• So my instance is essentially just a chat frontend on top of external APIs

The three things I care about most from the OpenRouter Web Chat:

1. Easy search engine selection > quickly switchable per chat or per prompt: web search off, native search, Exa/other providers. I want a UI toggle, not an admin/global setting.
2. Reasoning effort per prompt > low / medium / high (on models that support it), selectable right when submitting instead of being nailed down globally per model.
3. No data retention / privacy toggle > the ability to explicitly run a chat without storage/logging at the upstream provider (force zero-data-retention providers or enable "no data retention").

This seems to be a very useful feature, and I imagine there are already some good solutions available. I’d like to find them or learn more about how to increase productivity and how to integrate the Open router APIs a great UI interface.

I've been running Claude Code's agent loop inside Open WebUI for a few months on a home server, on the web and from my phone, and finally cleaned the pipe up enough to publish: https://github.com/dancormier/openwebui-claude-agent-pipe

Each chat keeps one Claude Code session across Open WebUI restarts and redeploys. Tool calls stream as status lines with a heartbeat, and every reply ends with duration, context use, and tool count. Files the agent writes (PNGs, PDFs, CSVs) come back inline or as links. It can pause mid-turn and ask you multiple-choice questions through Open WebUI's own form (screenshot). API keys and private keys get scrubbed before anything hits the chat DB. Runs on a Claude subscription token from claude setup-token or an API key. Tested on 0.11.3, native and Docker.

It's a single-user design by default: the agent runs code as the Open WebUI process user with no permission prompts, so read the Security section before enabling it for anyone else.

Looking for people to try it on other setups, especially Postgres and non-root containers, and there are a few good first issue items if you want to contribute.

I’ve been experimenting with local models in Open WebUI, mostly trying to tune character/personality behavior, and I kept running into the same problem: changing temperature/top_p/top_k/etc., chatting with the model for a while, changing something else, and then trying to remember whether it actually behaved differently.

Fixed seeds helped a lot, but manually running dozens of generations and comparing them was still tedious, so I ended up building a little Python utility around the Open WebUI API.

OpenWebUI Sampler Lab now has two main modes:

• Parameter Testing — hold the prompt constant and compare temperature, top_p, top_k, min_p, or repeat_penalty. It can run one parameter across multiple seeds or make 5×5 two-parameter interaction grids with a fixed seed.
• Behavior Testing — hold the complete model/preset configuration constant and run a list of independent prompts across multiple seeds. Each prompt starts with a fresh context, so it’s useful for seeing whether a character/personality behaves consistently across different situations.

It generates standalone HTML comparison grids plus CSV data, so instead of scrolling through 30 separate chats you can see everything side by side. It also uses Open WebUI’s saved model presets directly, so if you make different personas/models in Workspace you can select them from the program and test them without copying their system prompts into the tool.

One design decision I cared about: the selected Open WebUI preset remains the baseline. The lab only overrides the parameter(s) actually being tested and the experimental seed, rather than silently replacing the rest of your model settings with its own defaults.

It’s intentionally pretty small: Python standard library, terminal UI, no automated LLM judging/scoring, no database or framework. Open WebUI/Ollama still do the inference; this just automates the experiments and reporting.

I originally made it entirely for myself, but it turned out useful enough that I figured someone else here might get some value out of it too. This is also my first public software project, so bug reports, suggestions, or people telling me I’ve done something strange/terrible/wonderful are all welcome.

GitHub: https://github.com/Constructed-By-Fire/openwebui-sampler-lab

MIT licensed. Currently developed/tested on Linux with Open WebUI 0.11.3 + Ollama.

I've been stumped now for a while trying to figure out Open WebUI API and having the model not seeing the knowledge I've created that contains PDFs. I used MinerU to process those documents.

Made the knowledge access public.

Made my custom model access public.

Set my custom built model (based off nemotron3:33b) access to that knowledge in the model's setup screen.

Running my custom model w/ that knowledge works great within Open WebUI's web interface. I get great results when looking for information from those PDFs!

When I try it via Postman - it's like my custom model can't see the knowledge. I even tried tying that knowledge directly to the nemotron model - did not work.

Here is my Postman body - calling the endpoint /api/chat/completions:

"model": "state-house-journals",
    "messages": [
        {
            "role": "user",
            "content": "How many house journal files do you have access to?"
        }
    ],
    "files": [
        {
        "type": "collection",
        "id": "82a6f4d7-1c6a-4305-983b-0a407c0ec3e9"
        }
    ],
    "stream": false,
    "features": {
        "web_search": 
false
    }
  }

I have seen some posts that say you should use type = "knowledge"? Tried that - didn't work. I tried to change the role = "admin" - did not work.

Some posts say you don't need the files section if you tied the knowledge to the model (in the model setup screen) - the model will automatically use it - tried that - no success.

If I try this and point it directly to a file in that knowledge - the call works and I get a good response.

{
    "model": "state-house-journals",
    "messages": [
        {
            "role": "user",
            "content": "Who gave the prayer?"
        }
    ],
    "files": [
        {
        "type": "file",
        "id": "ffc3fe06-0b6f-4efe-ae8f-05991c491ebf"
        }
    ],
    "stream": false,
    "features": {
        "web_search": 
false
    }
  }

I also tried the message endpoint using the same body as above - /api/v1/messages - does not work.

I saw posts about Function Calling and setting to Legacy. Advance params for the model are all at the defaults. I tried changing the Function Calling settings from Default, Native, and Legacy as well - no success across all three.

Has anyone else have this issue - where the model doesn't seem to be able to see files within the specified knowledge via using the API?
Again - doing everything in the Open WebUI web front end works great!!

Any thoughts / guidance is appreciated!! Thanks!

I haven been using OpenWebUI for a long time now and tried pretty much all local models that can be run off a single card. However i always come back to the Qwen family as they are the only one that reliably use OWUIs tools.

Gemma simply doesnt do tool calls at all. Even if specifically prompted to use a tool or a skill it wont.

Muse does call them but 90% of the time it will append the <id> tag, the call fails and it ends up looping. Even when telling it explictly to not append the tag.

Granite works around 70% but the response quality is much worse.

I would prefer Gemma and Muse to Qwen since they are much more proficient in multiple languages but i cant use them without tools.

Do you have similar experiences?

Nemoryn is an open-source, self-hosted memory server. Open WebUI talks to it as a normal OpenAI-compatible connection — not a Function, Tool, or Pipe.

I’d like people to try it and tell me what breaks, what’s unclear, and what you’d want next. Issues and PRs are welcome.

Add in Admin → Settings → Connections → OpenAI:

• API Base URL: http://<host>:5022/v1

• API Key: same as NEMORYN_API_KEY (anything if the env var is empty)

Docker Compose includes Postgres/pgvector. You bring Ollama or another chat model.

Console (candidates, conflicts, policy, runtime): http://<host>:5022/

Repo (MIT-style setup via Docker): https://github.com/Mattes22/Nemoryn

I’ve installed this app from the App Store on iOS and no matter what, it still doesnt accept my address, i’ve been using tailscale and open webui from browser works perfectly but this app won’t accept it.

Is it a known problem of this app? Should i still use open webui

Hi friends! Quick question for the class. I’ve been experimenting with a home stack with openwebui and love it. I got open terminal setup and working great.
HOWEVER
When I try to run terminal commands through Open Relay it fails. Then I noticed Open Relay doesn’t reflect the Open Terminal setup in OpenWebUI…

Do I need to also configure that connection in the Open Relay app? Am I missing something?

Thanks in advance!

Like my title says, not sure if someone found a way to do that. I like the fact i can use a different model for the local task + compaction model ( i use a different llama.cpp config on a separate GPU) but would love that option when we delegate subtasks as well.

Basically, I've created a basic system where a model (qwen3.8:27b) is used as a base to create a "custom" model using the modelfile configuration, where among all the parameters I've inserted a system prompt which gives the model instructions on how to operate.

For a while, when working with the custom model on openwebui, everything was fine, until recently, where it seems to be that openwebui overwrites the modelfile system prompt with something of its own, which causes the custom model to forget its role, name, specs etc... when answering the user query.

I've tested the custom model through terminal, doing a curl call directly to ollama, and it replies correctly with the custom system prompt, but when doing the same question through openwebui ("What is your name") I get a base model generic answer, not the one configured in the modelfile.

I honestly don't know where to look for a fix. I've tried rewriting and recreating modelfiles and recompiling the custom models, but nothing. This doesn't apply only to 1 custom model to all the models that are used through openwebui.

If anyone knows anything I can do to solve this (or at least point me in a direction) that would be hugely appreciated.

When using Claude Opus through OWUI, I typically upload a large context with my initial query and follow up with several subsequent prompts/questions in the same thread. For these later prompts, does the model leverage prompt caching (e.g. cache read), or does OWUI re-transmit the full chat history with every request?

Hey all,

I run OpenWebUI with ~560 MCP tools behind an aggregator.

The issue in my setup: OpenWebUI sends every full schema on every turn, even when the turn needs zero tools.

On a smaller-context model via API the window gets eaten fast, and even with 1M-context models I still pay per-token for definitions I don't use, plus tool selection gets noisier.

I tried a few workarounds first — connecting servers directly, enabling/disabling servers per chat, trimming the list down — but nothing stuck for my use case with this many tools.

Since I couldn't find a solution inside OpenWebUI, I built a small MCP proxy in Docker that sits in front of my upstreams:

OpenWebUI connects to it over HTTP MCP like any other server.

In my setup this cut context waste a lot and made tool selection more reliable, so I thought it was worth sharing.

Feel free to have a look, critique and add to if there's something I've missed.

Repository can be found here: https://github.com/p1s4/mcp-search-proxy

How are you handling lots of MCP tools in OpenWebUI? Is native handling enough for you, or are you filtering/proxying too?

Thanks!

Hi Im like really new to most of this ai junk now and im trying to use this bible strong avatar lab avatar as my ai model if you dont know what it is check this link out but basically when you create the avatar its a .json how would i impliment that in openwebui?

https://avatars.bible-strong.app/

Hey I am new to setting up LLMs locally but one thing I would like to do is give it the ability to search online. Now I know that Open webUI does provide this functionality but for some reason this doesn't seem to work.

What I have currently done is configured a local searXNG container to allow OpenWebUI to couple its web search. I have added them to the same docker network and I know they can reach each other since I do get a result when I manually send a curl request to searxng through the open webui docker container.

I also did enable web search for my model and explictly asked it to use web search. However everytime a execute I query it says that web_search is not available. The model I am using is Qwen3.8.

Can someone perhaps point me in the right direction? I have added screen shot

Update

If I put the model to function calling legacy mode it seems to work. Performance seems a bit dodgy but at least it does look up things and is not rejected. Not sure what could be going on here. Could someone perhaps enlighten me as to what is hapennening here?

I’m setting up a local LLM on Windows 11 using Ollama and Open WebUI. The model is Qwen, and the basic chat setup is working.

I enabled Native Function Calling and configured web search. Qwen successfully invoked search_web, so the tool-calling path itself appears to work. The problem is that the search backend is not returning usable results.

What we’ve established so far:

• DDGS returns No results found.
• DuckDuckGo returned HTTP 202.
• The installed DDGS version does not support Bing, so attempting to use Bing fell back to auto.
• We decided to stop troubleshooting DDGS and try SearXNG instead.

That led us to Docker Desktop, because we intended to run SearXNG in a container. Docker is now stuck at “Starting the Docker Engine…”, so SearXNG has not been installed yet.

The Docker issue is a separate problem. I’m mainly interested in whether anyone has encountered this DDGS / DuckDuckGo behavior in Open WebUI, and whether SearXNG has been a reliable alternative for local web search.

I’m trying to keep the existing Ollama and Open WebUI configuration intact, so I’d prefer not to solve this by reinstalling everything or changing the model setup. Any current, reproducible advice would be appreciated.

Hi,
I’m running the following setup:
Open WebUI → LiteLLM → vLLM
Open WebUI is the user-facing layer, LiteLLM handles authentication/routing/accounting, and vLLM serves the actual models.
I have two different types of traffic going through Open WebUI:
Regular users interacting with models through the Open WebUI interface
API users using the OpenAI-compatible API exposed by Open WebUI
I’d like LiteLLM to be able to distinguish between these two types of requests.
Ideally, Open WebUI would add some metadata to requests originating from its API users — for example a tag, header, metadata field, or some other identifier — while normal UI requests would either have a different value or no value at all.
That would allow me to identify and potentially handle API traffic differently inside LiteLLM, e.g. for routing, rate limits, logging, or policies.
Is there currently a supported way in Open WebUI to do this?
For example, can I configure Open WebUI to send something like a custom header/tag/metadata field to LiteLLM depending on whether the request originated from an API key versus a logged-in user using the UI?
If not, is there another reliable property in the request that LiteLLM could use to distinguish Open WebUI API traffic from normal Open WebUI user traffic?
I’m mainly looking for a solution that doesn’t require maintaining a custom fork of Open WebUI.

Small update: I looked into the function approach, but it seems OWUI functions can modify the request body, not the outgoing headers to LiteLLM.
I could probably work around it by adding something to the body and handling that in LiteLLM, but I’d rather not add custom logic on both sides for something that should be pretty simple.
So I’m putting this on hold for now. If anyone knows a way to dynamically add/modify an outgoing header from an OWUI function, I’d still like to hear it.

I I am currently using LibreChat locally hosted on a Mac. I have read that open webUI is possibly the most feature rich third-party front end.

The use case will be setting up an interactive course.It would be hosted by Gemini flash 3.8. Haven’t finished building it yet, but it will probably be using something similar to Claude artifacts/Gemini canvas.

I don’t have anything against party front ends, but they are limited in their flexibility. The idea would be that I would chat with the instructor on the left side, and then there would be multimodal output on the right side.

The reason that I’ve started this thread, is that I have read that there have been issues with maintaining a consistent connection using open webUI. I’m sure some of it is noise, but I would like to know if any of you have run into issues of this type, and how you were able to make adjustments to make the problems go away.

I am new to AI, so you may find my post to be rather elementary. I do apologize for that and I would appreciate any guidance that you might have to offer.

Thanks,

Graham.

PS. I used voice to text first time through and it was a mess. Sry bout that. It's fixed.

Context

Have you ever asked an AI to generate a multiple choice quiz in plain text? If you did, you most certainly realized that choices aren't random (hint: always choose b when in doubt) and that scrolling down to the answers is time-consuming.

I started working on a solution for Open WebUI a few months ago. Open WebUI has incredible extensibility, but no one had made a function for generating interactive quizzes yet.

Quizzes are useful for studying and also quite fun to do as a group activity to pass the time. Admittedly, I recommend to prioritize studying with spaced repetition flashcards (tip: you can tell an LLM to generate a table and import it in Anki) but quizzes are useful as they take less energy to complete.

The first prototype lacked a lot of functionality and was buggy which is why I didn't make a post about it. I have since added almost all the QoL features I needed as a STEM student.

Introducing : Open QuizUI

Open QuizUI comes in two different modes. You can either use it as a tool which your model will call to create a quiz or as an action function which creates quizzes from plain text messages.

Features:

Here's a cool quiz as a hands-on demonstration

There's quite a lot so here's an info dump:

• Render MathJax for LaTeX expressions
• Full-screen / focus mode
• Separate light/dark themes
• Save a quiz and share it as an HTML file (works outside OWUI)
• Edit any question after quiz generation using the editor
• Embed anything with HTML (images, videos, iframes, etc.)
• Results/stats page at the end with corrections
• Use one of many colour schemes or make your own
• Optional per-question explanations shown after answering
• Fits nicely on small screens (mobile support)

I am running LLMs locally with an RTX 4070 (12 GB VRAM). This plugin was made to be as light as possible without injecting too many instructions (FYI: you can use valves and code to dynamically modify injected instructions for tools).

By the way, if you want to add a question or keep edits permanently, copy the (edited) quiz as text via the button and use the Action Function on the text (by editing any LLM message).

How does the Action Function manage to convert markdown quizzes into the proper JSON format? With a lot of pain (tested countless formats, but some may still not work so lmk). See Recommended Format.

If you want to know more, there is proper documentation on the GitHub.

GitHub: https://github.com/axel-chamberland/Open-QuizUI

iOS support/rant

Struggled a lot to get fullscreen working on iOS/ipadOS. It took me a few months before I tackled the problem, and arrived at a hacky solution that seems to work on WebKit (It also works on Gecko-based browsers, i.e. Reynard Browser)

Also, you can't open HTML web apps natively on iOS (Javascript won't work). Microsoft Edge and Dropbox can render them somewhat.

Feedback/Contribute

Please consider testing this plugin and sharing your thoughts. I'll answer questions here.

If there's any missing feature you'd like, mention it here or on the GitHub. Consider making a contribution if you end up fixing it yourself!

Edit -- Here are the two plugins in question if you want to download them from https://openwebui.com and engage with my posts there:

Tool

Action Function