Bereit, zu Open WebUI beizutragen? Los geht's! 🚀

Möchten Sie in die Entwicklung von Open WebUI einsteigen? Dieser umfassende Leitfaden führt Sie schnell und einfach durch die Einrichtung Ihrer lokalen Entwicklungsumgebung. Egal, ob Sie ein erfahrener Entwickler sind oder gerade erst anfangen, wir machen Sie bereit, das Frontend zu optimieren, das Backend zu erweitern und zur Zukunft von Open WebUI beizutragen! Lassen Sie uns Ihre Entwicklungsumgebung mit einfachen, detaillierten Schritten einrichten und zum Laufen bringen!

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Ihr System die Mindestanforderungen erfüllt

• Betriebssystem: Linux (oder WSL unter Windows), Windows 11 oder macOS. (Empfohlen für beste Kompatibilität)
• Python: Version 3.11 oder höher. (Erforderlich für Backend-Dienste)
• Node.js: Version 22.10 oder höher. (Erforderlich für die Frontend-Entwicklung)
• IDE (Empfohlen): Wir empfehlen die Verwendung einer IDE wie VSCode für die Codebearbeitung, das Debugging und den integrierten Terminalzugriff. Fühlen Sie sich frei, Ihre bevorzugte IDE zu verwenden, wenn Sie eine haben!
• [Optional] GitHub Desktop: Für eine einfachere Verwaltung des Git-Repositorys, insbesondere wenn Sie mit der Kommandozeile von Git weniger vertraut sind, sollten Sie die Installation von GitHub Desktop in Erwägung ziehen.

Einrichtung Ihrer lokalen Umgebung

Wir werden sowohl das Frontend (Benutzeroberfläche) als auch das Backend (API und Serverlogik) von Open WebUI einrichten.

1. Repository klonen

Klonen Sie zuerst das Open WebUI-Repository mit git clone auf Ihren lokalen Rechner herunter. Dadurch wird eine lokale Kopie des Projekts auf Ihrem Computer erstellt.

1. Öffnen Sie Ihr Terminal (oder Git Bash, wenn Sie unter Windows Git Bash verwenden).
2. Navigieren Sie zu dem Verzeichnis, in dem Sie das Open WebUI-Projekt speichern möchten.
3. Klonen Sie das Repository: Führen Sie den folgenden Befehl aus

git clone https://github.com/open-webui/open-webui.git
cd open-webui

Der Befehl git clone lädt die Projektdateien von GitHub herunter. Der Befehl cd open-webui navigiert Sie dann in das neu erstellte Projektverzeichnis.

2. Frontend-Einrichtung (Benutzeroberfläche)

Lassen Sie uns zuerst die Benutzeroberfläche (das, was Sie in Ihrem Browser sehen) zum Laufen bringen

1. Umgebungsvariablen konfigurieren

   • Kopieren Sie die Beispielumgebungsdatei nach .env

     cp -RPp .env.example .env

     Dieser Befehl kopiert die Datei .env.example in eine neue Datei namens .env. In der Datei .env werden die Umgebungsvariablen für das Frontend konfiguriert.

   • Passen Sie .env an: Öffnen Sie die Datei .env in Ihrem Code-Editor (z. B. VSCode). Diese Datei enthält Konfigurationsvariablen für das Frontend, wie API-Endpunkte und andere Einstellungen. Für die lokale Entwicklung sind die Standardeinstellungen in .env.example in der Regel ausreichend, um zu beginnen. Sie können diese jedoch bei Bedarf anpassen.

Wichtig: Übertragen Sie keine sensiblen Informationen in .env, wenn Sie zum Repository beitragen.

1. Frontend-Abhängigkeiten installieren

   • Navigieren Sie zum Frontend-Verzeichnis: Wenn Sie sich nicht bereits im Projektstammverzeichnis (open-webui) befinden, stellen Sie sicher, dass Sie dort sind.

     # If you are not in the project root, run:
     cd open-webui

   • Installieren Sie die erforderlichen JavaScript-Pakete

     npm install

     Dieser Befehl verwendet npm (Node Package Manager), um die Datei package.json im Stammverzeichnis des Projekts zu lesen und alle erforderlichen JavaScript-Bibliotheken und -Tools herunterzuladen, die für die Ausführung des Frontends benötigt werden. Dies kann je nach Ihrer Internetverbindung einige Minuten dauern.

2. Starten Sie den Frontend-Entwicklungsserver

   npm run dev

   Dieser Befehl startet den Frontend-Entwicklungsserver. Wenn die Schritte erfolgreich waren, wird normalerweise angezeigt, dass der Server läuft und eine lokale URL bereitgestellt wird.

   🎉 Greifen Sie auf das Frontend zu: Öffnen Sie Ihren Webbrowser und rufen Sie https://:5173 auf. Sie sollten eine Meldung sehen, die besagt, dass das Frontend von Open WebUI läuft und auf das Backend wartet. Machen Sie sich vorerst keine Sorgen um diese Meldung! Lassen Sie uns als Nächstes das Backend einrichten. Lassen Sie dieses Terminal laufen – es bedient Ihr Frontend!

3. Backend-Einrichtung (API und Server)

Für eine reibungslosere Entwicklungserfahrung empfehlen wir dringend, separate Terminalinstanzen für Ihre Frontend- und Backend-Prozesse zu verwenden. Dies hält Ihre Arbeitsabläufe organisiert und erleichtert die unabhängige Verwaltung jedes Teils der Anwendung.

Warum separate Terminals?

• Prozessisolation: Die Frontend- und Backend-Entwicklungsserver sind eigenständige Programme. Wenn Sie sie in separaten Terminals ausführen, stellen Sie sicher, dass sie sich nicht gegenseitig beeinträchtigen und ermöglichen unabhängige Neustarts oder Stopps.
• Klarere Protokolle und Ausgaben: Jedes Terminal zeigt die Protokolle und Ausgaben an, die speziell für das Frontend oder das Backend bestimmt sind. Dies erleichtert das Debugging und die Überwachung erheblich, da Sie nicht durch verschachtelte Protokolle suchen müssen.
• Reduzierte Terminal-Unübersichtlichkeit: Das Mischen von Frontend- und Backend-Befehlen in einem Terminal kann verwirrend werden. Separate Terminals halten Ihren Befehlsverlauf und aktive Prozesse organisiert.
• Verbesserte Workflow-Effizienz: Sie können im einen Terminal an Frontend-Aufgaben arbeiten (z. B. npm run dev ausführen) und gleichzeitig Backend-Aufgaben (z. B. Server starten oder Protokolle überprüfen) im anderen verwalten, ohne ständig den Kontext in einem einzelnen Terminal wechseln zu müssen.

Verwendung integrierter VSCode-Terminals (empfohlen)

Die integrierte Terminalfunktion von VSCode macht die Verwaltung mehrerer Terminals unglaublich einfach. So nutzen Sie sie für die Trennung von Frontend und Backend

1. Frontend-Terminal (wahrscheinlich haben Sie das bereits): Wenn Sie die Schritte zur Frontend-Einrichtung befolgt haben, haben Sie wahrscheinlich bereits ein Terminal in VSCode im Projektstammverzeichnis (open-webui) geöffnet. Hier führen Sie Ihre Frontend-Befehle aus (npm run dev usw.). Stellen Sie sicher, dass Sie sich im Verzeichnis open-webui befinden, wenn Sie mit den nächsten Schritten fortfahren, falls Sie dies noch nicht sind.

2. Backend-Terminal (Neues öffnen)

   • Gehen Sie in VSCode zu Terminal > Neues Terminal (oder verwenden Sie die Verknüpfung Strg+Umschalt+ unter Windows/Linux oder Cmd+Umschalt+ unter macOS). Dies öffnet ein neues integriertes Terminalfenster.
   • Navigieren Sie zum Verzeichnis backend: Wechseln Sie in diesem neuen Terminal mit dem Befehl cd backend in den Ordner backend innerhalb Ihres Projekts. Dies stellt sicher, dass alle Backend-bezogenen Befehle im richtigen Kontext ausgeführt werden.

   Sie haben nun zwei separate Terminalinstanzen in VSCode: eine für das Frontend (wahrscheinlich im Verzeichnis open-webui) und eine speziell für das Backend (im Verzeichnis backend). Sie können in VSCode einfach zwischen diesen Terminals wechseln, um Ihre Frontend- und Backend-Prozesse unabhängig voneinander zu verwalten. Diese Einrichtung wird für einen saubereren und effizienteren Entwicklungs-Workflow dringend empfohlen.

Backend-Einrichtungsschritte (in Ihrem Backend-Terminal)

1. Navigieren Sie zum Backend-Verzeichnis: (Sie sollten sich in Ihrem neuen Terminal aus dem vorherigen Schritt bereits im Verzeichnis backend befinden). Wenn nicht, führen Sie aus

   cd backend

2. Conda-Umgebung erstellen und aktivieren (empfohlen)

   • Wir empfehlen dringend die Verwendung von Conda zur Verwaltung von Python-Abhängigkeiten und zur Isolierung Ihrer Projektumgebung. Dies verhindert Konflikte mit anderen Python-Projekten auf Ihrem System und stellt sicher, dass Sie die richtige Python-Version und die erforderlichen Bibliotheken haben.

     conda create --name open-webui python=3.11
     conda activate open-webui
     • conda create --name open-webui python=3.11: Dieser Befehl erstellt eine neue Conda-Umgebung namens open-webui mit der Python-Version 3.11. Wenn Sie eine andere Python 3.11.x-Version gewählt haben, ist das in Ordnung.
     • conda activate open-webui: Dieser Befehl aktiviert die neu erstellte Conda-Umgebung. Nach der Aktivierung ändert sich Ihre Terminalaufforderung normalerweise, um anzuzeigen, dass Sie sich in der Umgebung open-webui befinden (z. B. steht am Anfang der Zeile (open-webui)).

   Stellen Sie sicher, dass Sie die Umgebung in Ihrem Backend-Terminal aktivieren, bevor Sie fortfahren.

   (Die Verwendung von Conda ist optional, wird aber zur Verwaltung von Python-Abhängigkeiten und zur Vermeidung von Konflikten dringend empfohlen.) Wenn Sie sich gegen die Verwendung von Conda entscheiden, stellen Sie sicher, dass Sie Python 3.11 oder höher verwenden und fahren Sie mit dem nächsten Schritt fort, aber seien Sie sich möglicher Abhängigkeitskonflikte bewusst.

3. Backend-Abhängigkeiten installieren

   • Führen Sie in Ihrem Backend-Terminal (und mit aktivierter Conda-Umgebung, wenn Sie Conda verwenden) aus

   pip install -r requirements.txt -U

   Dieser Befehl verwendet pip (Python Package Installer), um die Datei requirements.txt im Verzeichnis backend zu lesen. requirements.txt listet alle Python-Bibliotheken auf, die das Backend zum Ausführen benötigt. pip install lädt diese Bibliotheken herunter und installiert sie in Ihrer aktiven Python-Umgebung (Ihrer Conda-Umgebung, wenn Sie sie verwenden, oder andernfalls Ihrer systemweiten Python-Umgebung). Das Flag -U stellt sicher, dass Sie die neuesten kompatiblen Versionen der Bibliotheken erhalten.

4. Starten Sie den Backend-Entwicklungsserver

   • Führen Sie in Ihrem Backend-Terminal aus

   sh dev.sh

   Dieser Befehl führt das Skript dev.sh aus. Dieses Skript enthält wahrscheinlich den Befehl zum Starten des Backend-Entwicklungsservers. (Sie können die Datei dev.sh in Ihrem Code-Editor öffnen und untersuchen, um den genauen ausgeführten Befehl zu sehen, wenn Sie neugierig sind.) Der Backend-Server wird normalerweise gestartet und gibt einige Ausgaben im Terminal aus.

   📄 Erkunden Sie die API-Dokumentation: Sobald das Backend läuft, können Sie die automatisch generierte API-Dokumentation in Ihrem Webbrowser unter https://:8080/docs aufrufen. Diese Dokumentation ist äußerst wertvoll, um die Backend-API-Endpunkte zu verstehen, wie Sie mit dem Backend interagieren und welche Daten es erwartet und zurückgibt. Halten Sie diese Dokumentation während der Entwicklung griffbereit!

🎉 Herzlichen Glückwunsch! Wenn Sie alle Schritte befolgt haben, sollten Sie jetzt sowohl den Frontend- als auch den Backend-Entwicklungsserver lokal laufen haben. Gehen Sie zurück zu Ihrem Browser-Tab, über den Sie auf das Frontend zugegriffen haben (normalerweise https://:5173). Aktualisieren Sie die Seite. Sie sollten nun die vollständige Open WebUI-Anwendung in Ihrem Browser sehen, die mit Ihrem lokalen Backend verbunden ist!

Fehlerbehebung bei häufigen Problemen

Hier sind Lösungen für einige häufige Probleme, auf die Sie während der Einrichtung oder Entwicklung stoßen könnten

💥 "FATAL ERROR: Reached Heap Limit" (Frontend)

Dieser Fehler, der häufig während der Frontend-Entwicklung auftritt, zeigt an, dass Node.js während des Build-Prozesses der Speicher ausgeht, insbesondere bei der Arbeit mit großen Frontend-Anwendungen.

Lösung: Erhöhen Sie die Heap-Größe von Node.js. Dies gibt Node.js mehr Speicher zur Verfügung. Sie haben einige Optionen

1. Verwendung der NODE_OPTIONS Umgebungsvariablen (empfohlen für die Entwicklung)

   • Dies ist eine temporäre Methode, um das Speicherlimit für die aktuelle Terminalsitzung zu erhöhen. Bevor Sie npm run dev oder npm run build in Ihrem Frontend-Terminal ausführen, setzen Sie die Umgebungsvariable NODE_OPTIONS

     export NODE_OPTIONS="--max-old-space-size=4096" # For Linux/macOS (bash, zsh)
     # set NODE_OPTIONS=--max-old-space-size=4096 # For Windows (Command Prompt)
     # $env:NODE_OPTIONS="--max-old-space-size=4096" # For Windows (PowerShell)
     npm run dev

     Wählen Sie den für Ihr Betriebssystem und Terminal geeigneten Befehl. 4096 steht für 4 GB Speicher. Sie können diesen Wert bei Bedarf weiter erhöhen (z. B. 8192 für 8 GB). Diese Einstellung gilt nur für Befehle, die in der aktuellen Terminalsitzung ausgeführt werden.

2. Dockerfile ändern (für Docker-Umgebungen)

   • Wenn Sie mit Docker arbeiten, können Sie die Umgebungsvariable NODE_OPTIONS dauerhaft in Ihrem Dockerfile festlegen. Dies ist nützlich für eine konsistente Speicherzuweisung in Docker-Umgebungen, wie im Beispiel des ursprünglichen Leitfadens gezeigt

     ENV NODE_OPTIONS=--max-old-space-size=4096

   • Ausreichend RAM zuweisen: Unabhängig von der Methode stellen Sie sicher, dass Ihr System oder Container genügend RAM für Node.js zur Verfügung hat. Mindestens 4 GB RAM werden empfohlen, und mehr könnte für größere Projekte oder komplexe Builds erforderlich sein. Schließen Sie unnötige Anwendungen, um RAM freizugeben.

⚠️ Portkonflikte (Frontend & Backend)

Wenn Sie Fehler im Zusammenhang mit Ports sehen, wie z. B. "Adresse bereits in Verwendung" oder "Port bereits belegt", bedeutet dies, dass eine andere Anwendung auf Ihrem System bereits Port 5173 (Standard für Frontend) oder 8080 (Standard für Backend) verwendet. Nur eine Anwendung kann einen bestimmten Port gleichzeitig nutzen.

Lösung

1. Konfliktierenden Prozess identifizieren: Sie müssen herausfinden, welche Anwendung den benötigten Port verwendet.

   • Linux/macOS: Öffnen Sie ein neues Terminal und verwenden Sie die Befehle lsof oder netstat
     • lsof -i :5173 (oder :8080 für den Backend-Port)
     • netstat -tulnp | grep 5173 (oder 8080) Diese Befehle listen die Prozess-ID (PID) und den Namen des Prozesses auf, der den angegebenen Port verwendet.
   • Windows: Öffnen Sie die Eingabeaufforderung oder PowerShell als Administrator und verwenden Sie netstat oder Get-NetTCPConnection
     • netstat -ano | findstr :5173 (oder :8080) (Eingabeaufforderung)
     • Get-Process -Id (Get-NetTCPConnection -LocalPort 5173).OwningProcess (PowerShell) Diese Befehle zeigen ebenfalls die PID des Prozesses an, der den Port verwendet.

2. Konfliktierenden Prozess beenden: Sobald Sie die Prozess-ID (PID) identifiziert haben, können Sie die Anwendung, die diesen Port verwendet, beenden. Seien Sie vorsichtig beim Beenden von Prozessen, insbesondere wenn Sie sich nicht sicher sind, um was es sich handelt.

   • Linux/macOS: Verwenden Sie den Befehl kill: kill <PID> (ersetzen Sie <PID> durch die tatsächliche Prozess-ID). Wenn der Prozess nicht mit kill beendet wird, können Sie kill -9 <PID> (erzwungenes Beenden) verwenden, aber seien Sie vorsichtig damit.
   • Windows: Verwenden Sie den Befehl taskkill in der Eingabeaufforderung oder PowerShell als Administrator: taskkill /PID <PID> /F (ersetzen Sie <PID> durch die Prozess-ID). Das Flag /F erzwingt die Beendigung.

3. Alternativ Ports ändern (Fortgeschritten)

   • Wenn Sie den konfliktierenden Prozess nicht beenden können (z. B. es handelt sich um einen Systemdienst, den Sie benötigen), können Sie Open WebUI so konfigurieren, dass es andere Ports für das Frontend und/oder Backend verwendet. Dies beinhaltet normalerweise die Änderung von Konfigurationsdateien.
     • Frontend-Port: Überprüfen Sie die Frontend-Dokumentation oder Konfigurationsdateien (oft in vite.config.js oder ähnlich), wie der Entwicklungs-Server-Port geändert werden kann. Möglicherweise müssen Sie auch die Datei .env anpassen, wenn das Frontend Umgebungsvariablen für den Port verwendet.
     • Backend-Port: Untersuchen Sie das Skript dev.sh oder die Backend-Konfigurationsdateien, um zu sehen, wie der Backend-Port festgelegt ist. Möglicherweise müssen Sie den Startbefehl oder eine Konfigurationsdatei ändern, um den Backend-Port zu ändern. Wenn Sie den Backend-Port ändern, müssen Sie wahrscheinlich die .env-Datei des Frontends aktualisieren, um auf die neue Backend-URL zu verweisen.

🔄 Hot Reload funktioniert nicht

Hot Reload (oder Hot Module Replacement - HMR) ist eine fantastische Entwicklungsfunktion, die Ihren Browser automatisch aktualisiert, wenn Sie Änderungen am Code vornehmen. Wenn es nicht funktioniert, kann dies Ihren Entwicklungs-Workflow erheblich verlangsamen.

Fehlerbehebungsschritte

1. Entwicklungsserver laufen lassen: Überprüfen Sie nochmals, ob sowohl npm run dev (Frontend) als auch sh dev.sh (Backend) in ihren jeweiligen Terminals laufen und keine Fehler aufgetreten sind. Suchen Sie im Terminal-Output nach Meldungen, die darauf hinweisen, dass sie laufen und im "Watch-Modus" oder "Entwicklungsmodus" sind. Wenn Fehler vorliegen, beheben Sie diese zuerst.
2. Auf Watch Mode/HMR-Meldungen prüfen: Wenn die Entwicklungsserver starten, sollten sie normalerweise Meldungen im Terminal ausgeben, die darauf hinweisen, dass Hot Reload oder Watch Mode aktiviert ist. Suchen Sie nach Formulierungen wie "HMR enabled", "watching for file changes" oder ähnlichem. Wenn Sie diese Meldungen nicht sehen, liegt möglicherweise ein Konfigurationsproblem vor.
3. Browser-Cache: Manchmal kann der Cache Ihres Browsers verhindern, dass Sie die neuesten Änderungen sehen, selbst wenn Hot Reload funktioniert. Versuchen Sie einen Hard Refresh in Ihrem Browser
   • Windows/Linux: Strg+Umschalt+R
   • macOS: Cmd+Umschalt+R
   • Alternativ können Sie versuchen, den Cache Ihres Browsers zu löschen oder das Frontend in einem privaten/Inkognito-Browserfenster zu öffnen.
4. Abhängigkeitsprobleme (Frontend): Veraltete oder beschädigte Frontend-Abhängigkeiten können manchmal Hot Reloading beeinträchtigen. Versuchen Sie, Ihre Frontend-Abhängigkeiten neu zu installieren

   • Führen Sie in Ihrem Frontend-Terminal aus

     rm -rf node_modules && npm install

     Dieser Befehl löscht das Verzeichnis node_modules (wo Abhängigkeiten gespeichert sind) und installiert sie dann von Grund auf neu. Dies kann Probleme beheben, die durch beschädigte oder veraltete Pakete verursacht werden.

5. Neustart des Backends erforderlich (für Backend-Änderungen): Hot Reload funktioniert normalerweise am besten für Frontend-Codeänderungen (UI, Styling, Komponenten). Für signifikante Backend-Codeänderungen (insbesondere Änderungen an der Serverlogik, API-Endpunkten oder Abhängigkeiten) müssen Sie möglicherweise den Backend-Server manuell neu starten (indem Sie sh dev.sh in Ihrem Backend-Terminal stoppen und erneut ausführen). Hot Reload für Backend-Änderungen ist oft weniger zuverlässig oder in vielen Backend-Entwicklungs-Setups nicht automatisch konfiguriert.
6. IDE/Editor-Probleme: In seltenen Fällen können Probleme mit Ihrer IDE oder Ihrem Code-Editor dazu führen, dass Dateiänderungen von den Entwicklungsservern nicht richtig erkannt werden. Versuchen Sie, Ihre IDE neu zu starten oder sicherzustellen, dass Dateien korrekt gespeichert werden.
7. Konfigurationsprobleme (Fortgeschritten): Wenn keiner der oben genannten Schritte funktioniert, liegt möglicherweise ein komplexeres Konfigurationsproblem mit dem Frontend- oder Backend-Entwicklungsserver-Setup vor. Konsultieren Sie die Projektdokumentation, Konfigurationsdateien (z. B. vite.config.js für das Frontend, Backend-Serverkonfigurationsdateien) oder suchen Sie Hilfe in der Open WebUI-Community oder bei den Maintainern.

Beitragen zu Open WebUI

Wir freuen uns sehr über Ihre Beiträge zu Open WebUI! Ihre Hilfe ist wertvoll, um dieses Projekt noch besser zu machen. Hier ist eine Kurzanleitung für einen reibungslosen und effektiven Beitragsworkflow

1. Projektstruktur verstehen: Nehmen Sie sich Zeit, sich mit der Projektverzeichnisstruktur vertraut zu machen, insbesondere mit den Ordnern frontend und backend. Schauen Sie sich den Code, die Konfigurationsdateien und die Dokumentation an, um ein Gefühl dafür zu bekommen, wie die Dinge organisiert sind.

2. Mit kleinen Beiträgen beginnen: Wenn Sie neu im Projekt sind, sollten Sie mit kleineren Beiträgen beginnen, wie z. B.

   • Verbesserung der Dokumentation: Tippfehler korrigieren, Erklärungen verdeutlichen, mehr Details zur Dokumentation hinzufügen.
   • Fehlerbehebungen: Gemeldete Fehler oder Probleme beheben.
   • Kleine UI-Verbesserungen: Styling verbessern, kleinere Layout-Probleme beheben. Diese kleineren Beiträge sind eine großartige Möglichkeit, sich mit dem Code und dem Beitragsprozess vertraut zu machen.

3. Größere Änderungen zuerst besprechen: Wenn Sie planen, eine bedeutende neue Funktion zu implementieren oder wesentliche Änderungen vorzunehmen, wird dringend empfohlen, Ihre Ideen zuerst mit den Projekt-Maintainern oder der Community zu besprechen. Sie können dies tun, indem Sie

   • Ein Issue im GitHub-Repository eröffnen, um Ihre Funktion oder Änderung vorzuschlagen.
   • Den Open WebUI-Community-Kanälen beitreten (falls verfügbar, prüfen Sie die README-Datei oder die Website des Projekts auf Links) und Ihre Ideen dort besprechen. Dies hilft sicherzustellen, dass Ihr Beitrag mit den Projektzielen übereinstimmt und vermeidet verschwendete Mühe für Funktionen, die möglicherweise nicht gemergt werden.

4. Einen separaten Branch für Ihre Arbeit erstellen: Niemals direkt in den dev-Branch committen. Erstellen Sie immer einen neuen Branch für jede Funktion oder Fehlerbehebung, an der Sie arbeiten. Dies hält Ihre Änderungen isoliert und erleichtert die Verwaltung und Einreichung von Pull-Requests.

   • Um einen neuen Branch (z. B. mit dem Namen mein-feature-branch) basierend auf dem dev-Branch zu erstellen

     git checkout dev
     git pull origin dev # Ensure your local dev branch is up-to-date
     git checkout -b my-feature-branch

5. Änderungen häufig committen und klare Commit-Nachrichten schreiben: Machen Sie kleine, logische Commits, während Sie Funktionen entwickeln oder Fehler beheben. Schreiben Sie klare und prägnante Commit-Nachrichten, die erklären, welche Änderungen Sie vorgenommen haben und warum. Gute Commit-Nachrichten erleichtern das Verständnis der Änderungshistorie und sind für die Zusammenarbeit unerlässlich.

   • Beispiel für eine gute Commit-Nachricht: Fix: Tippfehler in der Dokumentation für die Backend-Einrichtung korrigiert
   • Beispiel für eine gute Commit-Nachricht: Feat: Profilseite des Benutzers mit Anzeige grundlegender Informationen implementiert

6. Regelmäßig mit dem dev-Branch synchronisieren: Während Sie an Ihrem Branch arbeiten, synchronisieren Sie Ihren Branch regelmäßig mit den neuesten Änderungen vom dev-Branch, um Merge-Konflikte später zu minimieren

   git checkout dev
   git pull origin dev
   git checkout my-feature-branch
   git merge dev

   Lösen Sie alle Merge-Konflikte, die während des git merge-Schritts auftreten.

7. Tests ausführen (falls verfügbar) vor dem Pushen: Obwohl dieser Leitfaden keine spezifischen Testverfahren für Open WebUI detailliert beschreibt, ist es eine gute Praxis, alle verfügbaren Tests auszuführen, bevor Sie Ihren Code pushen. Überprüfen Sie die Projektdokumentation oder package.json (für Frontend) und Backend-Dateien auf testbezogene Befehle (z. B. npm run test, pytest usw.). Das Ausführen von Tests hilft sicherzustellen, dass Ihre Änderungen keine Regressionen eingeführt oder bestehende Funktionalität beschädigt haben.

8. Pull Request (PR) einreichen: Sobald Sie Ihre Arbeit abgeschlossen, getestet (falls zutreffend) und bereit sind, Ihre Änderungen beizusteuern, reichen Sie einen Pull Request (PR) an den dev-Branch des Open WebUI-Repositorys auf GitHub ein.

   • Gehen Sie zum Open WebUI-Repository auf GitHub.
   • Navigieren Sie zu Ihrem Branch.
   • Klicken Sie auf die Schaltfläche "Contribute" oder "Pull Request" (normalerweise grün).
   • Füllen Sie das PR-Formular aus
     • Titel: Geben Sie Ihrem PR einen klaren und aussagekräftigen Titel, der Ihre Änderungen zusammenfasst (z. B. "Fix: Problem mit der Validierung des Login-Formulars behoben").
     • Beschreibung: Geben Sie eine detailliertere Beschreibung Ihrer Änderungen, des Problems, das Sie lösen (falls zutreffend), und relevanter Kontext an. Verlinken Sie alle zugehörigen Issues, falls vorhanden.
   • Reichen Sie den PR ein.

   Projekt-Maintainer werden Ihren Pull Request überprüfen, Feedback geben und möglicherweise Ihre Änderungen mergen. Reagieren Sie auf Feedback und seien Sie bereit, Überarbeitungen vorzunehmen, wenn dies gewünscht wird.

Vielen Dank, dass Sie diesen umfassenden Leitfaden gelesen haben und für Ihr Interesse, zu Open WebUI beizutragen! Wir freuen uns darauf, Ihre Beiträge zu sehen und Ihnen zu helfen, Teil der Open WebUI-Community zu werden! 🎉 Viel Spaß beim Codieren!