Open WebUI installieren: lokale KI mit Ollama, Postgres, SearXNG und Tika
Open WebUI mit Docker Compose selbst hosten: Ollama für lokale Modelle, Postgres mit pgvector, Tika für Dokumente und SearXNG als Websuche, die vor jeder Suche fragt.
Auf YouTube ansehen
Inhalt
Open WebUI 0.13.3Ollama 0.40.16PostgreSQL 18 mit pgvector 0.8.7Apache Tika 4.2.0SearXNG 2026.11.15Caddy 2.11Docker 29.9Debian 13Open WebUI ist eine Weboberfläche für Sprachmodelle, die sich wie ChatGPT bedient, aber auf deinem Server läuft. Zusammen mit Ollama bleiben deine Chats, Dokumente und Modelle bei dir. In dieser Anleitung baue ich keine Minimalinstallation, sondern ein Setup für den Alltag:
- Ollama führt die Sprachmodelle lokal aus.
- Postgres mit pgvector speichert Chats, Benutzer und die Vektoren deiner Dokumente.
- Apache Tika liest PDFs, Word-Dateien und Tabellen aus.
- SearXNG sucht im Web, ohne dass deine Suchanfragen bei einem kommerziellen Suchdienst mit API-Schlüssel landen.
- Freigabe vor der Websuche: Bevor ein Suchbegriff den Server verlässt, zeigt Open WebUI ihn an und wartet auf „Erlauben“. Alles, was auf dem Server bleibt, läuft ohne Rückfrage.
- Caddy holt das HTTPS-Zertifikat.
Danach zeige ich, wie du eigene Dokumente als Wissen einbindest, Skills anlegst und daraus ein Modell-Preset baust.
Voraussetzungen
qwen3:14b (9,3 GB) mit Kontext hinein. Wie du die Karte an Docker durchreichst, steht in der Ollama-Dokumentation. Ohne Grafikkarte laufen Modelle zwar auch, aber für Websuche und Dokumente zu langsam. Was das konkret heißt und welche Alternative es gibt, steht im Abschnitt Ohne Grafikkarte.sudo aus und nutze Debian 13.{{domain}}. Sie muss mit einem A-Record auf die IP-Adresse deines Servers zeigen, und die Ports 80 und 443 müssen offen sein. Läuft der Server zu Hause ohne öffentliche IPv4-Adresse, machst du ihn mit Pangolin erreichbar.Schritt 1: Verzeichnis und Geheimnisse
Lege das Projektverzeichnis an:
mkdir -p ~/open-webui/searxng ~/open-webui/caddy
cd ~/open-webuiDie Passwörter und Schlüssel kommen in eine .env-Datei. openssl erzeugt zufällige Werte:
cat > .env <<EOF
DOMAIN={{domain}}
POSTGRES_PASSWORD=$(openssl rand -hex 24)
WEBUI_SECRET_KEY=$(openssl rand -hex 32)
SEARXNG_SECRET=$(openssl rand -hex 32)
EOF
chmod 600 .envWEBUI_SECRET_KEYsigniert die Anmelde-Token. Bleibt er gleich, bleiben alle nach einem Neustart angemeldet.SEARXNG_SECRETbraucht SearXNG intern.
Schritt 2: SearXNG konfigurieren
SearXNG ist eine Metasuchmaschine. Sie fragt mehrere Suchdienste ab und gibt die Ergebnisse gesammelt zurück. Open WebUI braucht die Ergebnisse als JSON, und das ist in SearXNG standardmäßig aus:
nano searxng/settings.ymluse_default_settings: true
server:
limiter: false
image_proxy: false
search:
formats:
- html
- jsonuse_default_settings: trueübernimmt alle Standardwerte. In der Datei steht nur, was abweicht.limiter: falseschaltet die Bremse gegen Bots aus. SearXNG ist hier nur im Docker-Netz erreichbar, und Open WebUI ist der einzige Nutzer.formatserlaubt zusätzlich JSON.
Schritt 3: Caddyfile
nano caddy/Caddyfile{$DOMAIN} {
reverse_proxy open-webui:8080
}{$DOMAIN} liest Caddy aus der Umgebungsvariable, die die Compose-Datei aus der .env weiterreicht. Mehr zu Caddy steht in meiner Caddy-Anleitung.
Schritt 4: Die Compose-Datei
nano compose.yamlservices:
open-webui:
image: ghcr.io/open-webui/open-webui:v0.13.3
container_name: open-webui
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
ollama:
condition: service_started
tika:
condition: service_started
searxng:
condition: service_started
environment:
WEBUI_URL: "https://${DOMAIN}"
WEBUI_SECRET_KEY: "${WEBUI_SECRET_KEY}"
DATABASE_URL: "postgresql://openwebui:${POSTGRES_PASSWORD}@postgres:5432/openwebui"
VECTOR_DB: "pgvector"
RAG_EMBEDDING_MODEL: "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
CONTENT_EXTRACTION_ENGINE: "tika"
TIKA_SERVER_URL: "http://tika:9998"
TIKA_SERVER_VERSION: "4"
ENABLE_WEB_SEARCH: "true"
WEB_SEARCH_ENGINE: "searxng"
SEARXNG_QUERY_URL: "http://searxng:8080/search?q=<query>"
ENABLE_TOOL_PERMISSIONS: "true"
ENABLE_TOOL_PERMISSIONS_AUTO: "true"
TOOL_PERMISSIONS_AUTO_PROMPT: "Require approval for every call of search_web and fetch_url, because the query leaves the server. All other tools (knowledge, notes, skills, memories, time) never require approval."
OLLAMA_BASE_URL: "http://ollama:11434"
ENABLE_OPENAI_API: "false"
ENABLE_COMMUNITY_SHARING: "false"
ENABLE_CHANNELS: "true"
volumes:
- ./data:/app/backend/data
ollama:
image: ollama/ollama:0.40.16
container_name: open-webui-ollama
restart: unless-stopped
environment:
OLLAMA_CONTEXT_LENGTH: "16384"
volumes:
- ./ollama:/root/.ollama
postgres:
image: pgvector/pgvector:0.8.7-pg18-trixie
container_name: open-webui-postgres
restart: unless-stopped
environment:
POSTGRES_USER: "openwebui"
POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
POSTGRES_DB: "openwebui"
volumes:
- ./postgres:/var/lib/postgresql
healthcheck:
test: ["CMD-SHELL", "pg_isready -U openwebui -d openwebui"]
interval: 10s
timeout: 5s
retries: 5
tika:
image: apache/tika:4.2.0-full
container_name: open-webui-tika
restart: unless-stopped
searxng:
image: searxng/searxng:2026.11.15-2d500cb6b
container_name: open-webui-searxng
restart: unless-stopped
environment:
SEARXNG_SECRET: "${SEARXNG_SECRET}"
volumes:
- ./searxng:/etc/searxng
caddy:
image: caddy:2.11
container_name: open-webui-caddy
restart: unless-stopped
environment:
DOMAIN: "${DOMAIN}"
ports:
- "80:80"
- "443:443"
- "443:443/udp"
volumes:
- ./caddy/Caddyfile:/etc/caddy/Caddyfile
- ./caddy/data:/data
- ./caddy/config:/configNur Caddy veröffentlicht Ports. Ollama, Postgres, Tika und SearXNG sind nur im internen Docker-Netz erreichbar, das Compose für das Projekt anlegt.
Die Einstellungen von Open WebUI
WEBUI_URL: Die öffentliche Adresse. Open WebUI braucht sie für Links und für die Anmeldung über externe Dienste.DATABASE_URL: Ohne diese Zeile speichert Open WebUI alles in einer SQLite-Datei. Postgres verträgt mehrere gleichzeitige Nutzer besser und lässt sich mitpg_dumpim laufenden Betrieb sichern.VECTOR_DB: "pgvector": Die Vektoren deiner Dokumente landen in derselben Postgres-Datenbank statt in einer eigenen Chroma-Datenbank im Ordnerdata. Open WebUI legt die Erweiterungvectorbeim ersten Start selbst an. Das Imagepgvector/pgvectorbringt sie mit.RAG_EMBEDDING_MODEL: Das Modell, das Texte in Vektoren umrechnet. Es läuft im Container von Open WebUI. Der Standardall-MiniLM-L6-v2ist für Englisch trainiert. Ich nehme ein mehrsprachiges Modell, damit deutsche Dokumente besser gefunden werden. Open WebUI lädt es beim ersten Start herunter. Wechselst du das Modell später, musst du alle Dokumente neu einlesen.CONTENT_EXTRACTION_ENGINEundTIKA_*: Dokumente gehen zum Auslesen an Tika. Für Tika 4 brauchst duTIKA_SERVER_VERSION: "4", weil sich die Schnittstelle geändert hat.ENABLE_WEB_SEARCH,WEB_SEARCH_ENGINE,SEARXNG_QUERY_URL: Die Websuche über SearXNG.<query>ersetzt Open WebUI durch den Suchbegriff.ENABLE_TOOL_PERMISSIONS,ENABLE_TOOL_PERMISSIONS_AUTO,TOOL_PERMISSIONS_AUTO_PROMPT: Die Freigabe vor der Websuche. Dazu gleich mehr.OLLAMA_BASE_URL: Die Adresse des Ollama-Containers.ENABLE_OPENAI_API: "false": Schaltet die Verbindung zu externen APIs ab. Sonst steht dort eine leere Verbindung zu OpenAI.ENABLE_COMMUNITY_SHARING: "false": Blendet die Schaltfläche aus, mit der Nutzer Chats in der öffentlichen Community von Open WebUI teilen können.ENABLE_CHANNELS: "true": Schaltet Kanäle ein, eine Art Gruppenchat, in dem Menschen und Modelle zusammen schreiben.
Warum OLLAMA_CONTEXT_LENGTH?
Open WebUI schickt bei jeder Nachricht die Beschreibungen seiner Werkzeuge mit: Websuche, Wissen, Notizen, Uhrzeit und einige mehr. Das waren bei mir rund 9.600 Token, bevor die eigentliche Frage überhaupt dazukam. Ohne die Variable schnitt Ollama den Prompt auf etwa 2.000 Token ab (truncating input prompt im Log). Das Modell sah dann keine Werkzeuge mehr und konnte weder suchen noch Dokumente lesen. Mit 16384 passen Werkzeuge, Verlauf und Suchergebnisse hinein. Mehr Kontext belegt mehr Grafikspeicher.
Die Versionen sind fest eingetragen. Neue Versionen von Open WebUI erscheinen oft und ändern regelmäßig Einstellungen. Ich aktualisiere lieber bewusst.
Schritt 5: Starten und ein Modell laden
cd ~/open-webui
sudo docker compose up -dDer erste Start dauert ein paar Minuten. Docker lädt rund 18 GB Images, und Open WebUI holt danach das Embedding-Modell. Den Fortschritt siehst du im Log:
sudo docker compose logs -f open-webuiWenn dort GET / HTTP/1.1" 200 auftaucht, ist die Oberfläche bereit. Mit Strg+C verlässt du das Log.
Jetzt braucht Ollama ein Modell. Für Websuche, Wissen und Skills muss es Werkzeuge aufrufen können. In der Modellbibliothek von Ollama erkennst du solche Modelle am Merkmal „tools“. Ich lade hier qwen3:4b, das sind 2,5 GB:
sudo docker compose exec ollama ollama pull qwen3:4b
sudo docker compose exec ollama ollama listGrößere Modelle antworten besser und rufen Werkzeuge zuverlässiger auf, brauchen aber mehr Grafikspeicher. Nimm das größte Modell mit „tools“, das samt 16.384 Token Kontext in deine Grafikkarte passt. Weitere Modelle lädst du später auch im Admin-Bereich unter „Einstellungen“ → „Verbindungen“ über „Ollama verwalten“.
Schritt 6: Admin-Konto anlegen
Öffne https://{{domain}} und lege ein Konto an. Das erste Konto wird automatisch Administrator. Jedes weitere Konto landet im Status „Ausstehend“ und kann erst chatten, wenn du es im Admin-Bereich unter „Benutzer“ freischaltest. Lege das Admin-Konto deshalb sofort an, bevor jemand anderes die Adresse aufruft.
Im Chat wählst du oben das Modell aus, zum Beispiel qwen3:4b.
Schritt 7: Websuche nur mit Freigabe
Mit Ollama bleibt alles auf deinem Server, bis auf eine Ausnahme: Bei einer Websuche geht der Suchbegriff über SearXNG an Suchmaschinen wie Google, Bing oder DuckDuckGo. Genau dafür will ich eine Rückfrage, für alles andere nicht.
Open WebUI kennt dafür drei Modi für Werkzeuge. Jeder Nutzer findet sie im Chat hinter dem Plus links im Eingabefeld unter „Werkzeug-Berechtigungen“:
- Vollzugriff: Das Modell nutzt alle Werkzeuge ohne Rückfrage.
- Um Bestätigung bitten: Jeder Werkzeugaufruf braucht einen Klick, auch das Lesen deiner Dokumente oder das Abfragen der Uhrzeit.
- Automatisch: Das Modell prüft jeden Aufruf gegen eine Richtlinie und markiert, ob er eine Freigabe braucht.
Die Variablen aus der Compose-Datei schalten „Automatisch“ ein. Nutzer, die noch nichts ausgewählt haben, starten damit. TOOL_PERMISSIONS_AUTO_PROMPT ist die Richtlinie: search_web und fetch_url brauchen eine Freigabe, alles andere nicht. Du findest sie später im Admin-Bereich unter „Einstellungen“ → „Benutzeroberfläche“.
Auf die Frage „Wo stelle ich laut Hausordnung mein Fahrrad ab? Und wie wird morgen das Wetter in Berlin?“ las das Modell die Hausordnung und die Uhrzeit ohne Rückfrage. Vor der Websuche hielt es an. Ein Klick auf „search_web erlauben?“ zeigt unter „Eingabe“ den Suchbegriff:

Erst mit „Erlauben“ geht der Suchbegriff an SearXNG. Mit „Ablehnen“ antwortet das Modell ohne Suche. Die Antwort kam danach mit „Keller, Raum 3“ aus der Hausordnung und der Wettervorhersage mit Quelle.
Im Admin-Bereich unter „Einstellungen“ → „Websuche“ gibt es außerdem die Option „Websuche-Bestätigung“. Sie zeigt beim Einschalten der Websuche einmal einen festen Hinweistext („Websuche verwenden?“). Den Suchbegriff siehst du dort nicht.
Schritt 8: Eigene Dokumente als Wissen
Unter „Arbeitsbereich“ → „Wissen“ legst du eine Sammlung an und lädst Dateien hoch. Tika liest den Text aus, das Embedding-Modell zerlegt ihn in Abschnitte und berechnet die Vektoren, und Postgres speichert sie. Nichts davon verlässt den Server.
Zum Test habe ich eine Word-Datei mit einer Hausordnung hochgeladen: Mülltonnen dienstags um 7 Uhr, Fahrräder in Keller Raum 3, Hausmeister unter Durchwahl 42. Auf die Frage „Wann wird der Müll geleert und wie erreiche ich den Hausmeister?“ kam die richtige Antwort mit Verweis auf das Dokument.
Dass die Vektoren wirklich in Postgres liegen, prüfst du so:
sudo docker compose exec postgres psql -U openwebui -d openwebui \
-c "select collection_name, count(*) from document_chunk group by 1;"Jede Datei bekommt eine eigene Sammlung file-…, und jede Wissenssammlung eine mit ihrer ID.
Schritt 9: Skills
Skills sind Anleitungen in Markdown, die du einmal schreibst und dann in jedem Chat nutzt. Das Modell sieht zunächst nur Name und Beschreibung. Passt eine Frage dazu, lädt es den Inhalt selbst nach. Du kannst einen Skill auch gezielt aufrufen: Tippe im Chat $, dann erscheint die Liste deiner Skills.
Unter „Arbeitsbereich“ → „Skills“ habe ich einen Skill „Compose-Datei prüfen“ angelegt:
# Compose-Datei prüfen
Prüfe eine Docker-Compose-Datei, die der Nutzer schickt, auf diese Punkte und antworte mit
einer Tabelle (Punkt, Befund, Empfehlung):
1. Images haben eine feste Version, kein `latest` und keinen fehlenden Tag.
2. Nur der Reverse Proxy veröffentlicht Ports. Datenbanken, Redis/Valkey und interne Dienste
haben keinen `ports`-Eintrag.
3. Passwörter und Schlüssel stehen nicht im Klartext in der Datei, sondern kommen aus einer `.env`.
4. Daten liegen in Volumes oder Bind-Mounts und überleben ein `docker compose down`.
5. `restart: unless-stopped` oder `always` ist gesetzt.
6. Datenbanken haben einen `healthcheck`, und abhängige Dienste warten mit
`condition: service_healthy`.
Schlage am Ende die korrigierte Datei vor. Erfinde keine Image-Versionen: Wenn du die aktuelle
Version nicht kennst, schreibe `<VERSION>`.Als Beschreibung habe ich eingetragen: „Prüft eine docker-compose.yml auf feste Versionen, offene Ports, Klartext-Passwörter, Volumes, Restart-Policy und Healthchecks.“ Die Beschreibung entscheidet, ob das Modell den Skill von allein findet. Schreibe sie deshalb konkret.
Ich habe dann ohne $ geschrieben: „Prüf bitte meine Compose-Datei“ und eine Datei mit postgres ohne Version, Passwort im Klartext und offenem Port 5432 beschrieben. Das Modell hat den Skill selbst geladen (view_skill) und eine korrigierte Datei mit <VERSION>, Healthcheck und ohne offenen Datenbank-Port vorgeschlagen.
Schritt 10: Ein Modell-Preset bauen
Unter „Arbeitsbereich“ → „Modelle“ baust du aus einem Modell, einem System-Prompt, Wissen, Skills und Standardfunktionen ein eigenes „Modell“. Für Nutzer sieht es aus wie jedes andere Modell in der Auswahl.

Mein „Hausassistent“ hat die Hausordnung als Wissen und die Websuche als Standardfunktion, sie ist also in jedem Chat direkt eingeschaltet. Der System-Prompt sagt: zuerst die Hausordnung, das Web nur, wenn dort nichts steht. Als Basismodell wählst du eines deiner Ollama-Modelle.
Unter „Zugriff“ legst du fest, wer das Preset sehen darf. So bekommt zum Beispiel nur die Gruppe „Familie“ den Hausassistenten.
Was Open WebUI sonst noch kann
Diese Funktionen findest du außerdem in Version 0.13.3:
- Notizen: Ein Editor für eigene Notizen, die das Modell im Chat durchsuchen und bearbeiten kann.
- Kanäle: Gruppenchats, in denen mehrere Nutzer schreiben und Modelle per Erwähnung mitmachen. Eingeschaltet mit
ENABLE_CHANNELS. - Erinnerungen: Open WebUI merkt sich Fakten über dich, zum Beispiel deine bevorzugte Sprache, und gibt sie dem Modell mit.
- Automatisierungen: Ein Prompt, ein Modell und ein Zeitplan. Der Server führt den Prompt dann selbst aus, zum Beispiel jeden Morgen eine Zusammenfassung von Nachrichten zu einem Thema.
- Kalender: Termine, die das Modell lesen und anlegen kann.
- Code-Interpreter: Das Modell schreibt Python-Code und führt ihn aus. Standardmäßig läuft das mit Pyodide im Browser, nicht auf dem Server.
- Sub-Agents: Das Modell gibt Teilaufgaben an ein weiteres Modell ab (
delegate_task). - Funktionen (Admin-Bereich): Eigene Erweiterungen in Python, zum Beispiel Filter, die jede Nachricht vor dem Senden verändern.
- Integrationen: Externe Tool-Server, die dem Modell weitere Werkzeuge geben.
- Gruppen und Berechtigungen: Unter „Admin-Bereich“ → „Benutzer“ → „Gruppen“ legst du fest, wer Websuche, Skills, Wissen oder Code-Ausführung nutzen darf.
Ohne Grafikkarte: externe API als Alternative
Auf einem VPS mit 4 vCPU und 8 GB RAM ohne Grafikkarte habe ich qwen3:4b ausprobiert. Für eine kurze Antwort schaffte es rund 10 Token pro Sekunde. Mit Werkzeugen wird es aber zäh: Allein die rund 9.600 Token Werkzeugbeschreibungen einzulesen dauerte über sieben Minuten, und das bei jedem Schritt. Nach 20 Minuten hatte das Modell noch kein einziges Werkzeug aufgerufen. Für einfache Chats ohne Websuche und Dokumente reicht die CPU, für das Setup aus dieser Anleitung nicht.
Hast du keine passende Hardware, kann Open WebUI zusätzlich eine externe API ansprechen, die wie die von OpenAI funktioniert. Ollama, Postgres, Tika und SearXNG bleiben trotzdem auf deinem Server. Deine Nachrichten, die gefundenen Abschnitte aus deinen Dokumenten und die Suchergebnisse gehen dann aber an den Anbieter des Modells.
Ich habe dafür OpenRouter getestet. Dort bekommst du mit einem Schlüssel Zugriff auf Modelle vieler Anbieter. So richtest du es ein:
- Bei OpenRouter ein Konto anlegen, Guthaben aufladen und unter „Keys“ einen Schlüssel mit Ausgabenlimit erzeugen.
- In Open WebUI im Admin-Bereich unter „Einstellungen“ → „Verbindungen“ die „OpenAI API“ einschalten.
- Als URL
https://openrouter.ai/api/v1eintragen und den Schlüssel einfügen. - In der Verbindung unter „Modell-IDs“ nur die Modelle eintragen, die deine Nutzer sehen sollen, zum Beispiel
openai/gpt-6-luna. Sonst stehen über 400 Modelle in der Auswahl.
Mit openai/gpt-6-luna (0,10 $ pro Million Eingabe-Token, 0,50 $ pro Million Ausgabe-Token) liefen Websuche, Wissen, Skills und die Freigabe aus dieser Anleitung in wenigen Sekunden. Eine kurze Frage kostete rund 0,00002 $, alle Chats für diese Anleitung zusammen 0,007 $.
Wer mehrere Anbieter und lokale Modelle zusammen verwalten will, kann LiteLLM davorschalten: ein Proxy mit OpenAI-kompatibler Schnittstelle, eigenen Schlüsseln und Budgets pro Nutzer. In Open WebUI trägst du LiteLLM dann genauso als OpenAI-Verbindung ein.
Backup
Wichtig sind die Postgres-Datenbank (Chats, Benutzer, Einstellungen, Vektoren) und der Ordner data (hochgeladene Dateien). Die Datenbank sicherst du im laufenden Betrieb:
cd ~/open-webui
sudo docker compose exec -T postgres pg_dump -U openwebui -Fc openwebui > owui.dumpDazu kommen data/uploads, die .env, die compose.yaml, searxng/settings.yml und die Caddyfile. Die Ordner data/cache und ollama brauchst du nicht unbedingt: Open WebUI lädt das Embedding-Modell bei Bedarf neu, die Sprachmodelle holst du mit ollama pull wieder. Für die Übertragung auf ein anderes Gerät eignet sich zum Beispiel Duplicati.
Open WebUI aktualisieren
- Lies die Release Notes. Open WebUI ändert häufig Einstellungen und Menüs.
- Erstelle ein Backup der Datenbank wie oben.
- Ändere die Tags in der
compose.yaml. - Lade die Images und starte neu:
sudo docker compose pull
sudo docker compose up -dOpen WebUI passt die Datenbank beim Start selbst an.
Häufige Fragen
Läuft Open WebUI komplett lokal?
Ja, mit Ollama bleiben Chats, Dokumente und Modelle auf deinem Server. Nur bei einer Websuche geht der Suchbegriff über SearXNG an externe Suchmaschinen. Mit der Richtlinie aus dieser Anleitung fragt Open WebUI vorher nach.
Welche Hardware brauche ich für lokale Modelle?
Für Websuche, Dokumente und Skills eine Grafikkarte, in deren Speicher das Modell samt 16.384 Token Kontext passt. Auf 4 vCPU ohne Grafikkarte dauerte bei mir allein das Einlesen der Werkzeugbeschreibungen über sieben Minuten pro Schritt.
Warum findet mein lokales Modell keine Werkzeuge?
Meist ist der Kontext zu klein. Ohne OLLAMA_CONTEXT_LENGTH kürzt Ollama den Prompt auf etwa 2.000 Token, und die Werkzeugbeschreibungen von Open WebUI sind rund 9.600 Token lang. Außerdem muss das Modell Werkzeuge unterstützen, in der Ollama-Bibliothek erkennbar am Merkmal tools.
Kann ich nur die Websuche bestätigen lassen und alles andere nicht?
Ja, mit dem Modus Automatisch und einer Richtlinie, die nur für search_web und fetch_url eine Freigabe verlangt. Das Modell entscheidet anhand der Richtlinie, eine harte Regel ist es nicht. Nutzer können außerdem selbst auf Vollzugriff umschalten.
Warum ändert sich nichts, wenn ich eine Variable in der compose.yaml ändere?
Open WebUI speichert die meisten Einstellungen beim ersten Start in der Datenbank. Danach gilt, was im Admin-Bereich steht. Ändere die Einstellung dort oder setze ENABLE_PERSISTENT_CONFIG auf false.
Als Amazon-Partner verdiene ich an qualifizierten Verkäufen.
Änderungsprotokoll
Komplett neu geschrieben für Open WebUI 0.13.3: Ollama mit größerem Kontext, Postgres mit pgvector statt SQLite und Chroma, Tika für Dokumente, SearXNG als Websuche mit Freigabe nur für Suchanfragen, Caddy für HTTPS, Abschnitte zu Wissen, Skills, Modell-Presets, Backup und externen APIs als Alternative ohne Grafikkarte.