⏱️ Démarrage rapide

Sponsored by n8n

Does your interface have a backend yet? Try n8n

Note importante concernant les rôles utilisateur et la confidentialité:

• Création de ladmin: Le premier compte créé sur Open WebUI obtient des privileges dadministrateur, permettant la gestion des utilisateurs et des paramètres système.
• Inscriptions des utilisateurs: Les inscriptions ultérieures débutent avec un statut En attente, nécessitant lapprobation de ladministrateur pour accéder.
• Confidentialité et sécurité des données: Toutes vos données, y compris les informations de connexion, sont stockées localement sur votre appareil. Open WebUI garantit une confidentialité stricte et aucune requête externe pour une meilleure sécurité et confidentialité.
  • Tous les modèles sont privés par défaut. Les modèles doivent être explicitement partagés via des groupes ou rendus publics. Si un modèle est attribué à un groupe, seuls les membres de ce groupe peuvent le consulter. Si un modèle est rendu public, tout utilisateur de linstance peut le voir.

Choisissez votre méthode dinstallation préférée ci-dessous :

• Docker: Officiellement pris en charge et recommandé pour la plupart des utilisateurs
• Python: Convient aux environnements à faible ressources ou pour un paramétrage manuel
• Kubernetes: Idéal pour des déploiements en entreprise nécessitant scalabilité et orchestration

Docker

Docker

Démarrage rapide avec Docker 🐳

Suivez ces étapes pour installer Open WebUI avec Docker.

Étape 1 : Récupérer l'image Open WebUI

Commencez par récupérer la dernière image Docker d'Open WebUI depuis le GitHub Container Registry.

docker pull ghcr.io/open-webui/open-webui:main

Étape 2 : Exécuter le conteneur

Exécutez le conteneur avec les paramètres par défaut. Cette commande inclut un mappage de volume pour garantir un stockage persistant des données.

docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

Options importantes

• Mappage de volume (-v open-webui:/app/backend/data) : Garantit un stockage persistant de vos données. Cela évite les pertes de données lors des redémarrages du conteneur.
• Mappage de port (-p 3000:8080) : Expose l'interface utilisateur (WebUI) sur le port 3000 de votre machine locale.

Utilisation du support GPU

Pour utiliser le support GPU Nvidia, ajoutez --gpus all à la commande docker run :

docker run -d -p 3000:8080 --gpus all -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:cuda

Mode utilisateur unique (désactivation de la connexion)

Pour contourner la page de connexion dans une configuration utilisateur unique, définissez la variable d'environnement WEBUI_AUTH sur False :

docker run -d -p 3000:8080 -e WEBUI_AUTH=False -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

attention

Vous ne pouvez pas passer du mode utilisateur unique au mode multi-utilisateurs après ce changement.

Configuration avancée : Connexion à Ollama sur un autre serveur

Pour connecter Open WebUI à un serveur Ollama situé sur un autre hôte, ajoutez la variable d'environnement OLLAMA_BASE_URL :

docker run -d -p 3000:8080 -e OLLAMA_BASE_URL=https://example.com -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Accéder à l'interface WebUI

Après le démarrage du conteneur, accédez à Open WebUI à l'adresse :

http://localhost:3000

Pour obtenir une aide détaillée sur chaque option Docker, consultez la documentation de Docker.

Mise à jour

Pour mettre à jour votre installation Docker locale vers la dernière version, vous pouvez utiliser Watchtower ou mettre à jour manuellement le conteneur.

Option 1 : Utiliser Watchtower

Avec Watchtower, vous pouvez automatiser le processus de mise à jour :

docker run --rm --volume /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once open-webui

(Remplacez open-webui par le nom de votre conteneur s'il est différent.)

Option 2 : Mise à jour manuelle

1. Arrêtez et supprimez le conteneur actuel :

   docker rm -f open-webui

2. Récupérez la dernière version :

   docker pull ghcr.io/open-webui/open-webui:main

3. Redémarrez le conteneur :

   docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

Les deux méthodes permettent de mettre à jour et de faire fonctionner votre instance Docker avec la dernière version.

Docker Compose

Configuration de Docker Compose

Utiliser Docker Compose simplifie la gestion des applications Docker multi-conteneurs.

Si vous navez pas Docker installé, consultez notre tutoriel dinstallation de Docker.

Docker Compose nécessite un package supplémentaire, docker-compose-v2.

Attention : Les anciens tutoriels Docker Compose peuvent faire référence à la syntaxe de la version 1, qui utilise des commandes comme docker-compose build. Assurez-vous de bien utiliser la syntaxe de la version 2, qui utilise des commandes comme docker compose build (notez lespace au lieu dun trait dunion).

Exemple de fichier docker-compose.yml

Voici un exemple de fichier de configuration pour configurer Open WebUI avec Docker Compose :

version: 3
services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/app/backend/data
volumes:
  open-webui:

Démarrage des services

Pour démarrer vos services, exécutez la commande suivante :

docker compose up -d

Script daide

Un script daide pratique appelé run-compose.sh est inclus avec le code source. Ce script aide à choisir les fichiers Docker Compose à inclure dans votre déploiement, simplifiant ainsi le processus de configuration.

---

Remarque : Pour le support des GPU Nvidia, remplacez limage ghcr.io/open-webui/open-webui:main par ghcr.io/open-webui/open-webui:cuda et ajoutez ce qui suit à la définition de votre service dans le fichier docker-compose.yml :

deploy:
  resources:
    reservations:
      devices:
        - driver: nvidia
          count: all
          capabilities: [gpu]

Cette configuration garantit que votre application peut utiliser les ressources GPU lorsque disponibles.

Podman

Utilisation de Podman

Podman est un moteur de conteneurs sans démon pour développer, gérer et exécuter des conteneurs OCI.

Commandes de base

• Exécuter un conteneur :

  podman run -d --name openwebui -p 3000:8080 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

• Lister les conteneurs en cours d'exécution :

  podman ps

Réseautage avec Podman

Si des problèmes de réseau surviennent, utilisez slirp4netns pour ajuster les paramètres réseau du pod afin de permettre au conteneur d'accéder aux ports de votre ordinateur.

Assurez-vous d'avoir slirp4netns installé, supprimez le conteneur précédent s'il existe avec podman rm, et démarrez un nouveau conteneur avec

  podman run -d --network=slirp4netns:allow_host_loopback=true --name openwebui -p 3000:8080 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Si vous utilisez Ollama depuis votre ordinateur (et non exécuté à l'intérieur d'un conteneur),

Une fois dans open-webui, accédez à Paramètres > Paramètres d'administration > Connexions et créez une nouvelle connexion API Ollama vers http://10.0.2.2:[OLLAMA PORT]. Par défaut, le port Ollama est 11434.

Consultez la documentation de Podman pour des configurations avancées.

Docker Swarm

Docker Swarm

Cette méthode d'installation nécessite des connaissances sur Docker Swarm, car elle utilise un fichier stack pour déployer 3 conteneurs distincts en tant que services dans un Docker Swarm.

Elle comprend des conteneurs isolés de ChromaDB, Ollama et OpenWebUI. De plus, des Variables d'Environnement préremplies sont incluses pour mieux illustrer la configuration.

Choisissez la commande appropriée en fonction de votre configuration matérielle :

• Avant de commencer :

  Les répertoires pour vos volumes doivent être créés sur l'hôte, ou vous pouvez spécifier un emplacement ou un volume personnalisé.

  L'exemple actuel utilise un répertoire isolé data, qui se trouve dans le même répertoire que le fichier docker-stack.yaml.

  • Par exemple :

    mkdir -p data/open-webui data/chromadb data/ollama

• Avec support GPU :

  Docker-stack.yaml

  version: 3.9
  
  services:
    openWebUI:
      image: ghcr.io/open-webui/open-webui:main
      depends_on:
          - chromadb
          - ollama
      volumes:
        - ./data/open-webui:/app/backend/data
      environment:
        DATA_DIR: /app/backend/data 
        OLLAMA_BASE_URLS: http://ollama:11434
        CHROMA_HTTP_PORT: 8000
        CHROMA_HTTP_HOST: chromadb
        CHROMA_TENANT: default_tenant
        VECTOR_DB: chroma
        WEBUI_NAME: Super Bot de Chat
        CORS_ALLOW_ORIGIN: "*" # Ceci est la valeur par défaut actuelle, devra être modifié avant une mise en production
        RAG_EMBEDDING_ENGINE: ollama
        RAG_EMBEDDING_MODEL: nomic-embed-text-v1.5
        RAG_EMBEDDING_MODEL_TRUST_REMOTE_CODE: "True"
      ports:
        - target: 8080
          published: 8080
          mode: overlay
      deploy:
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
  
    chromadb:
      hostname: chromadb
      image: chromadb/chroma:0.5.15
      volumes:
        - ./data/chromadb:/chroma/chroma
      environment:
        - IS_PERSISTENT=TRUE
        - ALLOW_RESET=TRUE
        - PERSIST_DIRECTORY=/chroma/chroma
      ports: 
        - target: 8000
          published: 8000
          mode: overlay
      deploy:
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
      healthcheck: 
        test: ["CMD-SHELL", "curl localhost:8000/api/v1/heartbeat || exit 1"]
        interval: 10s
        retries: 2
        start_period: 5s
        timeout: 10s
  
    ollama:
      image: ollama/ollama:latest
      hostname: ollama
      ports:
        - target: 11434
          published: 11434
          mode: overlay
      deploy:
        resources:
          reservations:
            generic_resources:
              - discrete_resource_spec:
                  kind: "NVIDIA-GPU"
                  value: 0
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
      volumes:
        - ./data/ollama:/root/.ollama
  

  • Prérequis supplémentaires :

    1. Assurez-vous que CUDA est activé, suivez les instructions spécifiques à votre OS et GPU.
    2. Activez la prise en charge GPU dans Docker, voir le Nvidia Container Toolkit
    3. Suivez le Guide ici pour configurer Docker Swarm avec votre GPU
    • Assurez-vous que GPU Resource est activé dans /etc/nvidia-container-runtime/config.toml et activez l'annonce des ressources GPU en décommentant swarm-resource = "DOCKER_RESOURCE_GPU". Le démon Docker doit être redémarré après la mise à jour de ces fichiers sur chaque nœud.

• Avec support CPU :

  Modifiez le service Ollama dans docker-stack.yaml et supprimez les lignes pour generic_resources:

      ollama:
    image: ollama/ollama:latest
    hostname: ollama
    ports:
      - target: 11434
        published: 11434
        mode: overlay
    deploy:
      replicas: 1
      restart_policy:
        condition: any
        delay: 5s
        max_attempts: 3
    volumes:
      - ./data/ollama:/root/.ollama

• Déployez la stack Docker :

  docker stack deploy -c docker-stack.yaml -d super-awesome-ai

Python

uv

Installation avec uv

Le gestionnaire d'exécution uv garantit une gestion transparente de l'environnement Python pour les applications comme Open WebUI. Suivez ces étapes pour démarrer :

1. Installer uv

Choisissez la commande d'installation appropriée pour votre système d'exploitation :

• macOS/Linux :

  curl -LsSf https://astral.sh/uv/install.sh | sh

• Windows :

  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

2. Exécuter Open WebUI

Une fois uv installé, utiliser Open WebUI est un jeu d'enfant. Utilisez la commande ci-dessous, en veillant à définir la variable d'environnement DATA_DIR pour éviter toute perte de données. Des exemples de chemins sont fournis pour chaque plateforme :

• macOS/Linux :

  DATA_DIR=~/.open-webui uvx --python 3.11 open-webui@latest serve

• Windows (PowerShell) :

  $env:DATA_DIR="C:\open-webui\data"; uvx --python 3.11 open-webui@latest serve

Mise à jour avec Python

Pour mettre à jour votre package local Open-WebUI à la dernière version en utilisant pip, suivez ces étapes simples :

pip install -U open-webui

L'option -U (ou --upgrade) garantit que pip met à jour le package vers la dernière version disponible.

Et voilà ! Votre package Open-WebUI est maintenant mis à jour et prêt à l'emploi.

Conda

Installer avec Conda

1. Créer un environnement Conda :

   conda create -n open-webui python=3.11

2. Activer l'environnement :

   conda activate open-webui

3. Installer Open WebUI :

   pip install open-webui

4. Démarrer le serveur :

   open-webui serve

Mise à jour avec Python

Pour mettre à jour votre package local Open-WebUI à la dernière version en utilisant pip, suivez ces étapes simples :

pip install -U open-webui

L'option -U (ou --upgrade) garantit que pip met à jour le package vers la dernière version disponible.

Et voilà ! Votre package Open-WebUI est maintenant mis à jour et prêt à l'emploi.

Venv

Utiliser des environnements virtuels

Créez des environnements Python isolés en utilisant venv.

Étapes

1. Créer un environnement virtuel :

   python3 -m venv venv

2. Activer l'environnement virtuel :

   • Sous Linux/macOS :

     source venv/bin/activate

   • Sous Windows :

     venv\Scripts\activate

3. Installer Open WebUI :

   pip install open-webui

4. Démarrer le serveur :

   open-webui serve

Mise à jour avec Python

Pour mettre à jour votre package local Open-WebUI à la dernière version en utilisant pip, suivez ces étapes simples :

pip install -U open-webui

L'option -U (ou --upgrade) garantit que pip met à jour le package vers la dernière version disponible.

Et voilà ! Votre package Open-WebUI est maintenant mis à jour et prêt à l'emploi.

Développement

Configuration du développement

Pour les développeurs souhaitant contribuer, consultez le Guide de développement dans Sujets avancés.

Kubernetes

Helm

Configuration de Helm pour Kubernetes

Helm vous aide à gérer les applications Kubernetes.

Prérequis

• Un cluster Kubernetes est configuré.
• Helm est installé.

Étapes

1. Ajouter le dépôt Helm Open WebUI :

   helm repo add open-webui https://open-webui.github.io/helm-charts
   helm repo update

2. Installer le chart Open WebUI :

   helm install openwebui open-webui/open-webui

3. Vérifier l'installation :

   kubectl get pods

Si vous prévoyez de mettre à l'échelle Open WebUI en utilisant plusieurs nœuds/pods/workers dans un environnement en cluster, vous devez configurer une base de données clé-valeur NoSQL. Il existe certaines variables d'environnement qui doivent être définies avec la même valeur pour toutes les instances du service, sinon des problèmes de cohérence, des sessions défaillantes et d'autres problèmes peuvent survenir !

Accéder à l'interface WebUI

Configurez le transfert de port ou l'équilibrage de charge pour accéder à Open WebUI depuis l'extérieur du cluster.

Kustomize

Configuration Kustomize pour Kubernetes

Kustomize vous permet de personnaliser les configurations YAML de Kubernetes.

Prérequis

• Un cluster Kubernetes est configuré.
• Kustomize est installé.

Étapes

1. Cloner les Manifests Open WebUI :

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

2. Appliquer les Manifests :

   kubectl apply -k .

3. Vérifier l'installation :

   kubectl get pods

attention

Si vous avez l'intention de faire évoluer Open WebUI en utilisant plusieurs nœuds/pods/workers dans un environnement en cluster, vous devez configurer une base de données NoSQL de type clé-valeur. Il existe des variables d'environnement qui doivent être définies avec les mêmes valeurs pour toutes les instances de service, sinon des problèmes de cohérence, des sessions défectueuses et d'autres problèmes peuvent survenir !

Accéder à l'interface WebUI

Configurez le transfert de port ou l'équilibrage de charge pour accéder à Open WebUI depuis l'extérieur du cluster.

Tiers

Pinokio.computer

Installation avec Pinokio.computer

Pour linstallation via Pinokio.computer, veuillez visiter leur site web :

https://pinokio.computer/

Le support pour cette méthode dinstallation est fourni sur leur site web.

Intégrations supplémentaires avec des tiers

(Ajoutez des informations sur les intégrations tierces lorsquelles seront disponibles.)

Prochaines étapes

Après linstallation, accédez à :

• http://localhost:3000 pour utiliser Open WebUI.
• ou http://localhost:8080/ lors dun déploiement Python.

Vous êtes maintenant prêt à commencer avec Open WebUI !

Utilisation dOpen WebUI avec Ollama

Si vous utilisez Open WebUI avec Ollama, assurez-vous de consulter notre Guide de démarrage avec Ollama pour apprendre à gérer vos instances Ollama avec Open WebUI.

Rejoignez la communauté

Besoin daide ? Des questions ? Rejoignez notre communauté :

• Discord Open WebUI
• GitHub Issues