Tag 13: LLM-Chat für das Team – Open WebUI, Keycloak und RAG mit Qdrant
Ziel: Das Team meldet sich per Keycloak an
https://chat.lab.internalan und stellt Fragen an eigene Dokumente – Embeddings von vLLM, Vektoren in Qdrant, alles über LiteLLM. · Dauer: ca. 180 min · Voraussetzung: Tag 12
Briefing
- Open WebUI läuft mit 2 Replikas: Postgres (CloudNativePG) für Benutzer und Chats, Redis für Websockets, ein RWX-Volume (Longhorn) für Uploads.
- Login nur per OIDC. Keycloak liefert die Gruppen im Claim
groups. Open WebUI leitet daraus die Rolle (ki-admins→ admin,ki-users→ user) und seine eigenen Gruppen ab. - RAG: Open WebUI schneidet Dokumente in Chunks, holt Embeddings über
den LiteLLM-Alias
embedund speichert sie in Qdrant. Bei jeder Frage holt es die Top-k-Chunks und gibt sie dem Chat-Modell als Kontext mit. - Embedding-Modell:
BAAI/bge-m3(MIT-Lizenz, 1024 Dimensionen, mehrsprachig) mit vLLM aufrke2-gpu-1.
Browser --TLS--> Traefik --> open-webui (x2) --OIDC--> keycloak (sso.lab.internal)
| | |
Postgres <--+ | +--> Qdrant (Vektoren)
Redis <------+ +--> LiteLLM :4000 --> vllm-chat (chat-*)
--> vllm-embed (embed)
Drill 1: Embedding-Modell auf der GPU
Das Chat-Modell aus Tag 11 belegt 80 % des GPU-Speichers,
vllm-embed bekommt 12 %.
mkdir -p ~/ki-lab/tag13 && cd ~/ki-lab/tag13
export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl config use-context rke2-lab
kubectl apply -f ~/ki-lab/code/chat-rag/vllm-embed.yaml
kubectl -n ki-models rollout status deploy/vllm-embed --timeout=15m
kubectl -n ki-models port-forward svc/vllm-embed 8001:8000 >/dev/null 2>&1 &
sleep 2
curl -s localhost:8001/v1/embeddings -H 'Content-Type: application/json' \
-d '{"model": "bge-m3", "input": ["Rufbereitschaft", "Bereitschaftsdienst"]}' \
| jq '{model, n: (.data | length), dim: (.data[0].embedding | length)}'Erwartet (gekürzt, kann je nach Version abweichen):
persistentvolumeclaim/vllm-embed-cache created
deployment.apps/vllm-embed created
service/vllm-embed created
deployment "vllm-embed" successfully rolled out
{
"model": "bge-m3",
"n": 2,
"dim": 1024
}
Warum? --runner=pooling schaltet vLLM in den
Embedding-Modus: Statt Tokens zu generieren, liefert das Modell einen
Vektor pro Eingabe. Ein Pod pro Modell, getrennt skalierbar – die drei
vLLM-Pods teilen sich die GPU per Time-Slicing (Tag 10).
Achtung: Die Summe aller
--gpu-memory-utilizationauf einer GPU muss unter 1,0 bleiben, sonst bricht der zuletzt gestartete Pod mit „not enough free memory” ab. Kontrolle:promq 'DCGM_FI_DEV_FB_USED'(Tag 10).
Fortschritt speichern? Kostenlos registrieren
Drill 2: Alias embed in
LiteLLM
Ergänze model_list in
~/ki-lab/code/litellm-prod/config.yaml (Tag 12) um den
Eintrag aus code/code-llm/litellm-models-code.yaml (dort
stehen code und embed; code
braucht erst Tag 14, schadet aber nicht):
- model_name: embed
litellm_params:
model: hosted_vllm/bge-m3
api_base: http://vllm-embed.ki-models:8000/v1
model_info:
mode: embeddingcd ~/ki-lab/code/litellm-prod
kubectl -n ki-gateway create configmap litellm-config --from-file=config.yaml \
--dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-gateway rollout restart deploy/litellm
kubectl -n ki-gateway rollout status deploy/litellm
export LITELLM_MASTER_KEY=sk-lab-master-1234 # Lab-Wert
API=https://llm.lab.internal
curl -s $API/v1/embeddings -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
-H 'Content-Type: application/json' -d '{"model": "embed", "input": "Hallo"}' \
| jq '{model, dim: (.data[0].embedding | length), usage}'Erwartet (gekürzt, kann je nach Version abweichen):
configmap/litellm-config configured
deployment.apps/litellm restarted
deployment "litellm" successfully rolled out
{
"model": "bge-m3",
"dim": 1024,
"usage": {
"prompt_tokens": 3,
"total_tokens": 3
}
}
Warum? hosted_vllm/ ist der LiteLLM-Provider für vLLM.
Ohne mode: embedding würde der Health-Check von LiteLLM das
Modell per Chat-Request prüfen und als „unhealthy” melden.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Qdrant per Helm
cd ~/ki-lab/tag13
kubectl create namespace ki-chat --dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-chat create secret generic qdrant-auth \
--from-literal=api-key=lab-qdrant-key-1234 # Lab-Wert
helm repo add qdrant https://qdrant.github.io/qdrant-helm
helm repo update
helm upgrade --install qdrant qdrant/qdrant --version 1.19.2 -n ki-chat \
-f ~/ki-lab/code/chat-rag/values-qdrant.yaml
kubectl -n ki-chat rollout status sts/qdrant
kubectl -n ki-chat port-forward svc/qdrant 6333:6333 >/dev/null 2>&1 &
sleep 2
curl -s -o /dev/null -w 'ohne Key: %{http_code}\n' localhost:6333/collections
curl -s localhost:6333/collections -H 'api-key: lab-qdrant-key-1234' | jq -c .Erwartet (gekürzt, kann je nach Version abweichen):
namespace/ki-chat created
secret/qdrant-auth created
Release "qdrant" does not exist. Installing it now.
STATUS: deployed
partitioned roll out complete: 1 new pods have been updated...
ohne Key: 401
{"result":{"collections":[]},"status":"ok","time":2.1e-06}
Warum? Das Chart liest den Key per lookup aus dem
vorhandenen Secret und legt ihn in qdrant-apikey ab.
Deshalb muss qdrant-auth vor
helm install existieren – und helm template
zeigt dir an dieser Stelle nur ein leeres Secret.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Keycloak, Realm und Gruppen-Claim
Für das Lab reicht Keycloak im Dev-Modus (Daten im Pod, weg nach
Neustart). sso.lab.internal zeigt wie alle
*.lab.internal auf Traefik (10.10.20.100, Tag
9).
kubectl create namespace keycloak
kubectl -n keycloak create secret generic keycloak-admin \
--from-literal=password=lab-kc-admin-1234 # Lab-Wert
kubectl apply -f ~/ki-lab/code/chat-rag/keycloak.yaml
kubectl -n keycloak rollout status deploy/keycloak --timeout=5m
curl -s https://sso.lab.internal/realms/master/.well-known/openid-configuration \
| jq -r .issuer
bash ~/ki-lab/code/chat-rag/keycloak-setup.sh | tr -d '\n' > oidc-client-secret.txt
wc -c < oidc-client-secret.txtErwartet (gekürzt, kann je nach Version abweichen; kcadm meldet auf stderr):
deployment "keycloak" successfully rolled out
https://sso.lab.internal/realms/master
Logging into http://localhost:8080 as user admin of realm master
Created new realm with id 'ki-lab'
Created new client with id '3f6c...'
...
32
Das Skript keycloak-setup.sh legt an:
| Objekt | Name | Zweck |
|---|---|---|
| Realm | ki-lab |
eigener Mandant, nie master nutzen |
| Client | open-webui (confidential) |
Redirect
https://chat.lab.internal/oauth/oidc/callback |
| Mapper | groups (Group Membership) |
flache Gruppennamen im ID-Token und Userinfo |
| Gruppen/User | ki-admins (anna), ki-users (ben), keine
(gast) |
Rollen-Test |
Prüfe, was Open WebUI später zu sehen bekommt:
SECRET=$(cat oidc-client-secret.txt)
claims() { python3 -c 'import sys,json,base64
p = sys.stdin.read().split(".")[1]
print(json.dumps(json.loads(base64.urlsafe_b64decode(p + "=="))))'; }
curl -s https://sso.lab.internal/realms/ki-lab/protocol/openid-connect/token \
-d grant_type=password -d client_id=open-webui -d client_secret="$SECRET" \
-d username=ben -d password=lab-ben-1234 -d scope=openid \
| jq -r .id_token | claims | jq -c '{preferred_username, email, groups}'Erwartet (kann je nach Version abweichen):
{"preferred_username":"ben","email":"[email protected]",
"groups":["ki-users","team-plattform"]}
Die Ausgabe ist hier umbrochen, jq -c liefert eine
Zeile. Warum? full.path=false liefert ki-users
statt /ki-users. Open WebUI vergleicht die Gruppennamen
wörtlich mit OAUTH_ALLOWED_ROLES – ein führender Slash und
niemand kommt rein.
Sicherheit: Der Password-Grant (
directAccessGrantsEnabled) dient nur diesem Test. Schalte ihn danach ab:kubectl -n keycloak exec deploy/keycloak -- /opt/keycloak/bin/kcadm.sh update clients/<id> -r ki-lab -s directAccessGrantsEnabled=false.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Postgres, Virtual Key und Secrets
Der CloudNativePG-Operator läuft seit Tag 12. Open WebUI bekommt ein
eigenes Cluster owui-db und einen eigenen Virtual Key für
das Team team-chat.
cd ~/ki-lab/tag13
kubectl apply -f ~/ki-lab/code/chat-rag/owui-db.yaml
kubectl -n ki-chat wait cluster/owui-db --for=condition=Ready --timeout=5m
kubectl -n ki-chat get secret owui-db-app -o jsonpath='{.data.uri}' \
| base64 -d | sed 's/:[^:@]*@/:***@/'; echo
H=(-H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json')
TEAM=$(curl -s $API/team/new "${H[@]}" -d '{"team_alias": "team-chat",
"models": ["chat-small", "chat-large", "embed"],
"max_budget": 50, "budget_duration": "30d"}' | jq -r .team_id)
OWUI_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
\"key_alias\": \"open-webui\", \"models\": [\"chat-small\", \"chat-large\",
\"embed\"]}" | jq -r .key)
kubectl -n ki-chat create secret generic owui-secrets \
--from-literal=litellm-key="$OWUI_KEY" \
--from-literal=webui-secret-key="$(openssl rand -hex 32)" \
--from-file=oidc-client-secret=oidc-client-secret.txt
kubectl -n ki-chat create configmap lab-ca --from-file=ca.crt=$HOME/ki-lab/lab-ca.crtErwartet (gekürzt, kann je nach Version abweichen):
cluster.postgresql.cnpg.io/owui-db created
cluster.postgresql.cnpg.io/owui-db condition met
postgresql://openwebui:***@owui-db-rw.ki-chat:5432/openwebui
secret/owui-secrets created
configmap/lab-ca created
Warum? WEBUI_SECRET_KEY signiert die Session-Tokens.
Ohne festen Wert erzeugt jede Replika ihren eigenen – Benutzer fliegen
dann bei jedem Request auf die andere Replika raus. Das Budget von 50
(Lab-Einheiten) gilt für das ganze Team, nicht pro Person.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Open WebUI per Helm
Die wichtigsten Zeilen aus
code/chat-rag/values-open-webui.yaml:
| Wert | Wirkung |
|---|---|
replicaCount: 2,
persistence.accessModes: [ReadWriteMany] |
zwei Pods teilen das Upload-Volume (Longhorn RWX) |
websocket.manager: redis |
Chart setzt REDIS_URL und
WEBSOCKET_REDIS_URL auf den mitgelieferten Redis |
ENABLE_PERSISTENT_CONFIG=False |
Env-Variablen gewinnen immer, Änderungen im Admin-UI sind nur bis zum Neustart gültig |
ENABLE_LOGIN_FORM=False, sso.oidc.* |
Login nur über Keycloak |
helm repo add open-webui https://helm.openwebui.com/
helm repo update
helm upgrade --install open-webui open-webui/open-webui --version 16.6.0 \
-n ki-chat -f ~/ki-lab/code/chat-rag/values-open-webui.yaml
kubectl -n ki-chat rollout status sts/open-webui --timeout=10m
kubectl -n ki-chat get pods,pvc,ingress
kubectl -n ki-chat logs open-webui-0 | grep -iE "qdrant|oauth|error" | head -5
curl -s https://chat.lab.internal/healthErwartet (gekürzt, kann je nach Version abweichen):
STATUS: deployed
partitioned roll out complete: 2 new pods have been updated...
NAME READY STATUS RESTARTS AGE
pod/open-webui-0 1/1 Running 0 3m
pod/open-webui-1 1/1 Running 0 2m
pod/open-webui-redis-6d9c7b8f5-x2kqp 1/1 Running 0 3m
pod/owui-db-1 1/1 Running 0 9m
pod/owui-db-2 1/1 Running 0 8m
pod/qdrant-0 1/1 Running 0 25m
NAME STATUS VOLUME CAPACITY ACCESS MODES
persistentvolumeclaim/open-webui Bound pvc-7c1e 20Gi RWX
...
NAME CLASS HOSTS ADDRESS PORTS
open-webui traefik chat.lab.internal 10.10.20.100 80, 443
{"status":true}
Warum? Bei persistence.enabled rendert das Chart ein
StatefulSet, das ein gemeinsames PVC einbindet. Longhorn stellt RWX über
einen NFS-Share-Manager bereit – auf allen Workern muss dafür
nfs-common installiert sein.
Tipp: Hängt der Login mit „OAuth callback failed”, prüfe zuerst Uhrzeit (NTP) auf allen Nodes, dann
OPENID_REDIRECT_URIgegen die Redirect-URIs des Clients in Keycloak.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Login und Rollen testen
Öffne https://chat.lab.internal in drei privaten
Browserfenstern und klicke „Weiter mit Keycloak”:
| Benutzer | Gruppen in Keycloak | Ergebnis in Open WebUI |
|---|---|---|
anna / lab-anna-1234 |
ki-admins, team-plattform |
Rolle admin, Admin-Panel sichtbar |
ben / lab-ben-1234 |
ki-users, team-plattform |
Rolle user, Modelle chat-small,
chat-large |
gast / lab-gast-1234 |
keine | Zugriff verweigert |
kubectl -n ki-chat exec owui-db-1 -c postgres -- psql -U postgres -d openwebui \
-c "select email, role from \"user\" order by email;" \
-c "select name from \"group\" order by name;"Erwartet (kann je nach Version abweichen):
email | role
------------------+-------
[email protected] | admin
[email protected] | user
(2 rows)
name
----------------
ki-admins
ki-users
team-plattform
(3 rows)
Warum? Melde dich zuerst als anna an: Der allererste
Benutzer wird immer admin, egal welche Gruppen er hat. Die Gruppen legt
Open WebUI dank ENABLE_OAUTH_GROUP_CREATION selbst an und
gleicht die Mitgliedschaft bei jedem Login ab. Rechte auf Modelle und
Wissen vergibst du an diese Gruppen, nicht an Personen.
Tipp: Neue Modelle sind in Open WebUI zunächst privat (nur Admins). Unter Admin-Panel → Einstellungen → Modelle stellst du
chat-smallundchat-largefür die Gruppeki-usersfrei,embedbleibt ausgeblendet.
Fortschritt speichern? Kostenlos registrieren
Drill 8: RAG von Hand
Bevor du der Oberfläche vertraust, baust du die Kette einmal selbst:
Chunks einbetten, in Qdrant speichern, Top-3 suchen, mit Kontext fragen.
Das Skript code/chat-rag/rag_check.py nutzt drei fiktive
Dokumente aus code/chat-rag/docs/.
python3 -m venv ~/ki-lab/.venv && source ~/ki-lab/.venv/bin/activate
pip install -q openai qdrant-client
export SSL_CERT_FILE=~/ki-lab/lab-ca.crt # Lab-CA für Python
export LITELLM_URL=$API/v1 LITELLM_KEY=$OWUI_KEY
export QDRANT_URL=http://localhost:6333 QDRANT_API_KEY=lab-qdrant-key-1234
python ~/ki-lab/code/chat-rag/rag_check.pyErwartet (gekürzt, Werte schwanken):
11 Chunks eingebettet, dim=1024, 0.31s
✔ [0.71 bereitschaft.md] Wie hoch ist die Pauschale pro Bereitschaftswoche?
-> 350 Euro pro angefangene Bereitschaftswoche. (1.1s)
✔ [0.66 bereitschaft.md] Wie schnell muss ich in der Bereitschaft bei P1 reagieren?
-> Innerhalb von 15 Minuten. (0.9s)
✔ [0.62 gpu-richtlinie.md] Wie hoch ist das LLM-Standardbudget eines Teams?
-> 50 Euro pro Monat. (0.8s)
✔ [0.74 vpn.md] Wie oft werden VPN-Schlüssel rotiert?
-> Alle 90 Tage. (0.7s)
4/4 Fragen korrekt beantwortet
Warum? Die Zahl in eckigen Klammern ist die Cosinus-Ähnlichkeit des
besten Treffers. Liegt die richtige Quelle nicht auf Platz 1, hilft kein
besseres Chat-Modell – dann musst du an Chunking, Embedding-Modell oder
Top-k drehen. Mit QDRANT_URL=:memory: läuft dasselbe Skript
ohne Qdrant-Server, z. B. gegen LiteLLM aus Tag 4.
Fortschritt speichern? Kostenlos registrieren
Drill 9: Wissenssammlung in Open WebUI
Jetzt dieselben Dokumente über die Oberfläche – als
anna:
- Arbeitsbereich → Wissen → +: Name
Plattform-Handbuch, Sichtbarkeit: Gruppeteam-plattform(Lesen). - Die drei Dateien aus
~/ki-lab/code/chat-rag/docs/hochladen. - Als
benneuer Chat mitchat-large,#Plattform-Handbucheintippen, Sammlung auswählen, fragen: „Wie hoch ist die Pauschale pro Bereitschaftswoche?”
Die Antwort nennt 350 Euro und zeigt die Quelle
bereitschaft.md als Zitat. Was ist in Qdrant gelandet?
Q=(-H 'api-key: lab-qdrant-key-1234')
curl -s localhost:6333/collections "${Q[@]}" | jq -r '.result.collections[].name'
curl -s localhost:6333/collections/open-webui_knowledge "${Q[@]}" \
| jq '.result | {points_count, size: .config.params.vectors.size}'Erwartet (gekürzt, kann je nach Version abweichen):
rag-check
open-webui_files
open-webui_knowledge
{
"points_count": 3,
"size": 1024
}
Warum? ENABLE_QDRANT_MULTITENANCY_MODE (Default
true) legt nicht pro Sammlung eine Collection an, sondern
wenige gemeinsame mit einem Feld tenant_id. Das hält Qdrant
bei hunderten Sammlungen schlank. Die Zugriffsrechte prüft allein Open
WebUI – wer direkt an Qdrant kommt, sieht alles.
Die RAG-Parameter stehen in den Values, nicht im Admin-UI
(ENABLE_PERSISTENT_CONFIG=False):
| Variable | Lab-Wert | Wirkung |
|---|---|---|
CHUNK_SIZE / CHUNK_OVERLAP |
1000 / 150 Zeichen | kleinere Chunks = präzisere Treffer, weniger Kontext |
RAG_TOP_K |
5 | Chunks pro Frage im Prompt |
RAG_EMBEDDING_BATCH_SIZE |
16 | Chunks pro Embedding-Request an LiteLLM |
RAG_FILE_MAX_SIZE |
25 (MB) | größere Uploads werden abgelehnt |
Achtung: Wechselst du das Embedding-Modell (z. B. von
bge-m3auf ein Modell mit 768 Dimensionen), passen die vorhandenen Vektoren nicht mehr. Dann musst du alle Sammlungen neu einbetten (Admin-Panel → Dokumente → Vektorspeicher neu indizieren).
Fortschritt speichern? Kostenlos registrieren
Drill 10: Datenschutz-Check
Ein Team-Chat speichert mehr, als man denkt. Wo liegt was?
| Daten | Ort | Löschen / Begrenzen |
|---|---|---|
| Chats, Benutzer, Feedback | Postgres owui-db |
Chat-Löschung durch Benutzer, Admin-Export, Backups beachten |
| Hochgeladene Dateien | PVC open-webui
(/app/backend/data/uploads) |
mit der Wissenssammlung löschen |
| Chunks im Klartext + Vektoren | Qdrant (Payload text) |
Sammlung löschen, Snapshots beachten |
| Prompts, Token-Zahlen, Kosten | LiteLLM Postgres (Tag 12) | disable_spend_logs bzw. Aufbewahrung festlegen |
curl -s localhost:6333/collections/open-webui_knowledge/points/scroll "${Q[@]}" \
-H 'Content-Type: application/json' -d '{"limit": 1, "with_vector": false}' \
| jq -r '.result.points[0].payload.text' | head -3Erwartet (kann abweichen):
# Bereitschaftsregelung Plattform-Team (Lab GmbH, fiktiv)
Die Rufbereitschaft wechselt jeden Montag um 09:00 Uhr. Die Übergabe erfolgt im
Warum? Der Vektorspeicher enthält den Dokumenttext im Klartext. Für ihn gelten dieselben Schutzregeln wie für die Originaldateien: API-Key, NetworkPolicy, verschlüsselte Volumes, Löschkonzept.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
K="kubectl -n ki-chat"
[ "$($K get sts open-webui -o jsonpath='{.status.readyReplicas}')" = "2" ] \
&& ok "Open WebUI 2/2 bereit" || nok "Open WebUI 2/2 bereit"
curl -sf https://chat.lab.internal/health >/dev/null \
&& ok "chat.lab.internal per TLS" || nok "chat.lab.internal per TLS"
curl -sf https://sso.lab.internal/realms/ki-lab/.well-known/openid-configuration \
>/dev/null && ok "Keycloak-Realm ki-lab" || nok "Keycloak-Realm ki-lab"
curl -sf $API/v1/embeddings -H "Authorization: Bearer $OWUI_KEY" \
-H 'Content-Type: application/json' -d '{"model":"embed","input":"x"}' \
| jq -e '.data[0].embedding | length == 1024' >/dev/null \
&& ok "embed liefert 1024 Dimensionen" || nok "embed liefert 1024 Dimensionen"
curl -sf localhost:6333/collections/open-webui_knowledge \
-H 'api-key: lab-qdrant-key-1234' | jq -e '.result.points_count > 0' >/dev/null \
&& ok "Wissen in Qdrant" || nok "Wissen in Qdrant"
$K exec owui-db-1 -c postgres -- psql -U postgres -d openwebui -tAc \
"select role from \"user\" where email='[email protected]'" | grep -qx user \
&& ok "ben hat Rolle user" || nok "ben hat Rolle user"Challenge
Ein RAG-System muss auch „weiß ich nicht” sagen können. Erweitere
rag_check.py um eine Frage, deren Antwort in keinem
Dokument steht, ohne das Skript selbst zu ändern.
Hinweis: QUESTIONS ist eine
Modul-Liste, und als erwartete Quelle ist None erlaubt.
Lösung
cd ~/ki-lab/tag13
cat > rag_negativ.py <<'PY'
import sys
sys.path.insert(0, sys.argv[1])
import rag_check # noqa: E402
rag_check.QUESTIONS.append(
("Wie heißt der Chef der Kantine?", None, "weiß ich nicht"))
sys.exit(rag_check.main())
PY
python rag_negativ.py ~/ki-lab/code/chat-rag | tail -3Erwartet (Werte schwanken):
✔ [0.38 vpn.md] Wie heißt der Chef der Kantine?
-> weiß ich nicht. (1.2s)
5/5 Fragen korrekt beantwortet
Der beste Treffer hat einen deutlich niedrigeren Score. Mit
RAG_RELEVANCE_THRESHOLD (nur zusammen mit Hybrid Search und
Reranker wirksam) filtert Open WebUI solche Treffer vorab heraus.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Keycloak über den Keycloak Operator mit eigenem Postgres, mindestens
2 Instanzen, Realm-Konfiguration als Code (z. B. keycloak-config-cli)
statt
kcadm.sh. - Ein Virtual Key für ganz Open WebUI verschleiert, wer was kostet.
ENABLE_FORWARD_USER_INFO_HEADERS=Truegibt LiteLLM die Benutzer-Mail mit – Auswertung und Datenschutz vorher klären. - Qdrant: API-Key aus OpenBao per ESO (Tag 12), NetworkPolicy nur von
open-webuiaus, Snapshots ins Backup (Tag 15). Das Chart liest den Key perlookup– mit Argo CD funktioniert das nicht, dortapiKeydirekt aus einem Secret perenvsetzen. - Vor dem Rollout: Verarbeitungsverzeichnis, Löschfristen für Chats, Betriebsrat (Leistungs- und Verhaltenskontrolle!) und eine Nutzungsrichtlinie, welche Daten in den Chat dürfen.
- Uploads auf S3-kompatiblen Speicher
(
persistence.provider: s3) statt RWX-Volume, sobald mehr als eine Handvoll Teams den Chat nutzen.