Votre ChatGPT local en 10 minutes : Open WebUI + Ollama (2026)

Open WebUI + Ollama : Le Guide d'Installation en 10 Minutes (2026)

Vous avez déjà souhaité que ChatGPT tourne sur votre ordinateur plutôt que sur les serveurs d'OpenAI ? Open WebUI + Ollama est exactement la pile qu'il vous faut. Open WebUI offre l'interface de chat soignée ; Ollama exécute les modèles localement. Pas de clés API, pas de facturation par token, aucune donnée ne quitte votre machine. Ce guide vous emmène d'un terminal vide à votre premier chat en environ dix minutes — puis couvre les choses que la plupart des tutoriels sautent : entrée/sortie vocale, Pipelines, MCP, benchmarks Apple Silicon et un chemin HTTPS propre avec Caddy.

Points clés :

• Open WebUI est un frontend auto-hébergé de type ChatGPT ; Ollama est le moteur de modèles local qui l'alimente.
• Le chemin Docker en conteneur unique vous amène au premier chat en ~10 minutes sur une machine déjà configurée.
• Définissez OLLAMA_BASE_URL sur http://host.docker.internal:11434 pour corriger l'erreur "impossible de se connecter" neuf fois sur dix.
• Les fonctionnalités phares d'Open WebUI sont Pipelines/Functions, RAG natif, entrée/sortie vocale et MCP — aucune de ces fonctionnalités n'est disponible dans LM Studio.

Qu'est-ce Qu'Open WebUI + Ollama, Vraiment ?

Open WebUI est une interface web open-source auto-hébergée qui donne à Ollama (et à d'autres runtimes LLM locaux) une interface de chat de type ChatGPT. Ensemble, ils vous permettent d'exécuter des modèles d'IA privés sur votre propre machine — pas de clés API, pas de coût par token, contrôle total des données. Open WebUI est la couche chat ; Ollama est la couche modèle. Ils communiquent via HTTP sur le port 11434, et c'est toute l'architecture.

Décomposons les éléments, car les noms semblent interchangeables mais ne le sont pas :

• Open WebUI — l'application navigateur que vous utilisez réellement. Multi-utilisateur, RAG intégré, système de plugins, tourne sur le port 8080 dans Docker (vous le mappez sur 3000 sur votre hôte).
• Ollama — le serveur de modèles. Il télécharge les fichiers GGUF (pensez .mp3 pour les modèles d'IA), les charge sur votre CPU/GPU et expose une API HTTP soignée sur le port 11434.
• Modèles — les fichiers de poids réels. llama3.2:3b, qwen2.5:14b, deepseek-r1:7b, etc. Téléchargés via ollama pull, listés dans la bibliothèque de modèles d'Ollama.

Pourquoi cette combinaison gagne : confidentialité (les données restent locales), coût (zéro par token), capable de fonctionner hors ligne, multi-utilisateur dès le départ et un véritable écosystème de plugins. Si vous êtes nouveau dans ce domaine, notre guide sur l'exécution locale des LLMs couvre l'aspect matériel.

La documentation officielle d'Open WebUI est la référence canonique — mettez-la en favoris. Elle est concise, mais précise.

Comment Installer Open WebUI avec Ollama ? (Configuration Rapide)

Installez Docker, installez Ollama, puis exécutez docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main. Visitez http://localhost:3000, créez le compte administrateur, récupérez un modèle depuis Admin → Paramètres → Connexions → Ollama et commencez à chatter. Temps total : environ 10 minutes sur une machine déjà configurée.

Voici le chemin complet, étape par étape :

1. Installer Docker Desktop — téléchargez-le depuis docker.com pour Mac/Windows, ou apt install docker.io sur Linux.

2. Installer Ollama

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows : télécharger l'installateur depuis ollama.com

3. Récupérer un modèle de démarrage. Je commencerais par llama3.2:3b — rapide sur presque tout, assez intelligent pour être utile. Si vous voulez un tour des options les plus performantes, consultez notre liste des meilleurs LLMs open-source.

ollama pull llama3.2:3b

4. Exécuter le conteneur Open WebUI (la commande canonique) :

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

5. Ouvrez http://localhost:3000, inscrivez-vous (le premier utilisateur devient automatiquement administrateur) et vous chatteez.

Conseil pro : Sur les Macs Apple Silicon, exécutez Ollama nativement (pas dans Docker). C'est intentionnel — cela permet à Ollama d'utiliser le GPU Metal. Open WebUI tourne dans Docker ; les deux communiquent via host.docker.internal:11434.

À propos de la promesse des "10 minutes" : c'est un chiffre pour une machine déjà configurée — Docker déjà installé, connexion internet correcte pour le téléchargement de l'image (~2 Go) et du modèle (~2 Go). Première installation Docker sans cache ? Ajoutez dix minutes pour ça. Connexion lente ? Ajoutez encore cinq. Référence honnête, pas un chiffre marketing.

Docker Compose : La Configuration Prête pour la Production

Si vous voulez une configuration multi-conteneurs reproductible pour Open WebUI plus un service Ollama autonome, Docker Compose est le chemin le plus propre. Un fichier YAML déclare les deux services, un réseau partagé, des volumes nommés pour la persistance et vous permet de redéployer avec un simple docker compose up -d. Idéal pour les serveurs, les homelabs ou les équipes.

L'astuce qui fait trébucher les gens : quand les deux services tournent dans Compose, définissez OLLAMA_BASE_URL=http://ollama:11434 (le nom du service Compose), pas host.docker.internal. Le DNS interne de Docker résout automatiquement le nom du service.

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: always

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui:/app/backend/data
    depends_on:
      - ollama
    restart: always

volumes:
  ollama:
  open-webui:

Démarrez-le :

docker compose up -d
docker compose logs -f

Deux remarques à souligner. Premièrement, les volumes nommés (ollama: et open-webui: en bas) sont préférables aux bind mounts ici — Docker gère les permissions et votre historique de chat/configuration survit aux reconstructions de conteneurs. Deuxièmement, si vous voulez qu'un Open WebUI parle à Ollama local et à OpenAI/Anthropic distant via une seule URL, placez un proxy LiteLLM devant. Et si vous choisissez encore votre couche runtime, notre tour d'horizon des meilleurs outils LLM locaux couvre Ollama, vLLM, LM Studio et compagnie.

Accélération GPU : NVIDIA, AMD et Apple Silicon

Ollama détecte automatiquement les GPUs NVIDIA via le NVIDIA Container Toolkit, les GPUs AMD via ROCm sur Linux et les GPUs Apple Silicon nativement via Metal. Vous ne passez pas --gpus all à Open WebUI — seul Ollama a besoin du GPU. La configuration la plus rapide sur chaque plateforme est différente, et certains moments "pourquoi c'est lent ?" sont liés au fait qu'Ollama est au mauvais endroit.

NVIDIA (Linux + Windows WSL2)

Installez le NVIDIA Container Toolkit, puis exécutez Ollama dans Docker avec --gpus all :

docker run -d --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Vérifiez avec nvidia-smi pendant qu'un modèle est chargé — vous devriez voir ollama dans la liste des processus GPU. La variable d'environnement OLLAMA_NUM_GPU vous permet de limiter les couches quand vous partagez la VRAM avec d'autres charges de travail.

Apple Silicon (M1/M2/M3/M4)

Exécutez Ollama nativement — pas dans Docker. Il n'y a pas encore de passthrough GPU Metal dans Docker (début 2026), donc un Ollama dockerisé sur Mac revient au CPU, et vous vous demanderez pourquoi votre M3 Max se comporte comme un ThinkPad de 2015. Open WebUI tourne toujours dans Docker ; il atteint Ollama via host.docker.internal:11434.

Sur mon M2 Pro (16 Go) avec llama3.2:3b, j'obtiens environ 45-55 tokens/s. llama3.1:8b descend à ~22-28 tokens/s. qwen2.5:14b est à la limite à ~9-12 tokens/s — acceptable pour le chat, pénible pour le travail par lots. Les chiffres varient avec la quantification et la longueur du contexte, mais c'est l'ordre de grandeur.

AMD (ROCm sur Linux)

Ollama 0.5+ intègre le support ROCm pour les cartes RDNA2/RDNA3 (séries RX 6000/7000, puces datacenter MI200/MI300). Utilisez l'image dédiée :

docker run -d --device=/dev/kfd --device=/dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

Les performances AMD ont rattrapé significativement leur retard tout au long de 2025 — pas encore au niveau NVIDIA, mais ce n'est plus un projet expérimental.

Comment Ajouter RAG (Mes Propres PDFs) à Open WebUI ?

Open WebUI intègre le RAG nativement. Cliquez sur votre profil → Workspace → Connaissances, créez une base de connaissances et déposez des PDFs, des documents Word, du Markdown ou des fichiers texte. En arrière-plan, Open WebUI découpe les documents, les intègre avec le modèle d'embedding configuré (par défaut nomic-embed-text), les stocke dans ChromaDB et les récupère lors des requêtes. Aucun service externe requis.

La configuration nécessite une étape supplémentaire : téléchargez d'abord le modèle d'embedding.

ollama pull nomic-embed-text

Ensuite, dans Admin → Paramètres → Documents, définissez le modèle d'embedding sur nomic-embed-text. Ajustez la taille des chunks (par défaut 1500) et le chevauchement (par défaut 100) selon vos besoins. L'erreur classique : des chunks trop grands dépassent votre fenêtre de contexte sur les petits modèles. Si vous utilisez llama3.2:3b avec un contexte de 4K, des chunks de 1500 tokens laissent presque pas de place pour la vraie question — réduisez à 800 avec un chevauchement de 80.

Pour utiliser une base de connaissances dans le chat, tapez # et choisissez la collection. Ou attachez-la de façon permanente à un Modèle Personnalisé dans Workspace → Modèles. La recherche web fonctionne de façon similaire — activez un fournisseur (SearXNG, Brave ou Tavily) dans Admin → Paramètres → Recherche Web, et le modèle peut récupérer des résultats en direct.

Pour une comparaison RAG plus approfondie, consultez notre tour d'horizon des outils RAG. Et si ChromaDB ne convient plus à grande échelle, notre analyse des options de base de données vectorielle couvre Qdrant, pgvector et les compromis.

Entrée/Sortie Vocale : Parler à Votre IA Locale

Open WebUI prend en charge à la fois la reconnaissance vocale (STT) et la synthèse vocale (TTS). Pour STT, faster-whisper tourne localement sans clé API. Pour TTS, vous pouvez connecter l'API TTS d'OpenAI ou faire tourner un moteur local comme coqui-tts. Une fois activé, une icône microphone apparaît dans la boîte de chat et votre IA locale commence à vous répondre.

Allez dans Admin → Paramètres → Audio. Deux moteurs, deux menus déroulants.

Chemin STT — choisissez Whisper (Local), choisissez une taille de modèle : tiny, base, small, medium ou large. Le modèle se télécharge automatiquement à la première utilisation. base est le meilleur compromis pour la plupart des portables ; medium si vous avez de la marge GPU.

Chemin TTS — le plus simple est OpenAI TTS : collez une clé API, choisissez tts-1 et une voix (alloy, nova, etc.). Chemin entièrement local : moteur coqui-tts avec une image Docker séparée. La plupart des gens optent pour Whisper local + OpenAI TTS comme compromis pragmatique — votre audio ne quitte jamais la machine pour l'entrée, et l'appel API n'est qu'une courte chaîne de texte pour la sortie.

Vous pouvez intégrer le choix dans le conteneur avec des variables d'environnement :

docker run -d \
  -e WHISPER_MODEL=base \
  -e AUDIO_STT_ENGINE=whisper \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

La référence audio complète se trouve dans la documentation GitHub d'Open WebUI.

Pipelines & Functions : La Fonctionnalité Phare d'Open WebUI

Pipelines et Functions sont la façon d'étendre Open WebUI sans le forker. Les Pipelines sont des services Python externes qui agissent comme des filtres, des routeurs de modèles ou des gestionnaires personnalisés complets. Les Functions sont du Python inline (Filter, Action ou Pipe) qui vivent dans Open WebUI lui-même. Ensemble, c'est pourquoi Open WebUI surpasse LM Studio pour les utilisateurs sérieux.

Trois types de Functions, une phrase chacune :

• Filter — pré/post-traite les messages (suppression des PII, filtre de grossièretés, réécriture des prompts).
• Action — un bouton dans l'interface de chat qui déclenche du Python (résumer à nouveau, sauvegarder dans Notion, exécuter une requête SQL).
• Pipe — un gestionnaire de modèle personnalisé complet (router vers une API distante, enchaîner plusieurs modèles, construire un agent).

Voici un Filter minimal qui supprime les adresses e-mail des prompts utilisateur avant qu'ils n'atteignent le modèle :

from pydantic import BaseModel
import re

class Filter:
    class Valves(BaseModel):
        priority: int = 0

    def __init__(self):
        self.valves = self.Valves()

    def inlet(self, body: dict, __user__: dict = None) -> dict:
        for message in body.get("messages", []):
            if message.get("role") == "user":
                message["content"] = re.sub(
                    r"[\w\.-]+@[\w\.-]+",
                    "[REDACTED_EMAIL]",
                    message["content"],
                )
        return body

Collez ça dans Admin → Paramètres → Functions → Nouveau, sauvegardez et activez-le pour n'importe quel modèle. Terminé.

Pour les Pipelines externes, lancez le conteneur dédié à côté d'Open WebUI :

  pipelines:
    image: ghcr.io/open-webui/pipelines:main
    container_name: pipelines
    ports:
      - "9099:9099"
    volumes:
      - pipelines:/app/pipelines
    restart: always

Puis dans Admin → Paramètres → Connexions, ajoutez http://pipelines:9099 comme API compatible OpenAI. Téléchargez des fichiers .py dans Admin → Paramètres → Pipelines. Le dépôt officiel Pipelines contient des dizaines d'exemples — routeurs de traduction, logging Langfuse, appel de fonctions, et bien plus.

MCP : Connecter Open WebUI aux Outils Externes

Open WebUI 0.6+ prend en charge le Model Context Protocol (MCP), ce qui signifie que votre modèle local peut appeler des outils externes — recherche de fichiers, GitHub, Slack, vos propres serveurs personnalisés — via le même protocole utilisé par Claude Desktop. C'est la façon la plus propre de donner à un modèle local une vraie utilisation d'outils sans écrire un Pipeline.

Ajoutez un serveur MCP dans Admin → Paramètres → Outils : collez l'URL du serveur, donnez-lui un nom et activez-le par modèle. Le modèle décide quand l'appeler pendant le chat. Nous couvrons le protocole de bout en bout dans notre guide sur le Model Context Protocol (MCP) — mêmes patterns, juste du côté d'Open WebUI plutôt que de Claude Desktop.

Pourquoi c'est important : à mi-2026, presque aucun tutoriel Open WebUI ne mentionne MCP. Si vous avez déjà standardisé sur des serveurs MCP pour votre configuration Claude ou Cursor, vous pouvez pointer Open WebUI vers exactement les mêmes serveurs. Un protocole, tous les clients.

Pourquoi Open WebUI Ne Voit Pas Mes Modèles Ollama ? (Dépannage)

Si Open WebUI se charge mais que le menu déroulant des modèles est vide, le conteneur ne peut pas atteindre Ollama. Neuf fois sur dix, la solution est --add-host=host.docker.internal:host-gateway plus OLLAMA_BASE_URL=http://host.docker.internal:11434. Sur Linux sans le flag host-gateway, le réseau bridge de Docker ne peut pas voir le port 11434 de l'hôte. La première fois que nous avons déployé ça sur la machine Linux d'un client, nous avons rencontré exactement ce problème et perdu une heure.

Trois causes racines, par ordre de fréquence :

1. Flag --add-host manquant (le plus courant sur Linux). macOS Docker Desktop définit host.docker.internal automatiquement ; Linux nécessite le flag explicite.

2. Ollama lié uniquement à 127.0.0.1. Du point de vue du conteneur, c'est inaccessible. Solution :

   bash

   OLLAMA_HOST=0.0.0.0:11434 ollama serve

   Ou définissez Environment="OLLAMA_HOST=0.0.0.0:11434" dans l'unité systemd sur Linux.

3. Pare-feu / antivirus bloquant le port 11434. Moins courant, mais vérifiez ufw, Windows Defender ou la protection des endpoints d'entreprise.

Diagnostic — exécutez ceci depuis l'intérieur du conteneur Open WebUI :

docker exec open-webui curl http://host.docker.internal:11434/api/tags

Si ça renvoie du JSON avec votre liste de modèles, le réseau est bon et le problème est dans les paramètres d'Open WebUI (vérifiez Admin → Connexions → URL Ollama). Si ça se bloque ou refuse, vous avez un problème côté hôte — commencez par la cause n°2.

Open WebUI vs LM Studio vs Jan vs AnythingLLM

Open WebUI gagne sur le multi-utilisateur, la profondeur du RAG et Pipelines/Functions. LM Studio gagne sur les performances GPU d'emblée et une interface mono-utilisateur soignée. Jan gagne sur la facilité du premier démarrage. AnythingLLM gagne sur l'ergonomie d'ingestion de documents. Si vous voulez un remplacement ChatGPT auto-hébergé pour une équipe, Open WebUI est la réponse.

Verdict : si vous êtes un développeur solo qui veut juste exécuter un modèle sur son GPU de gaming et chatter, LM Studio est plus rapide à configurer. Si vous construisez un ChatGPT privé pour une équipe, faites du RAG sérieux ou câblez de la logique Python personnalisée, Open WebUI est le seul vrai choix. Notre article sur les meilleurs outils LLM locaux compare la couche runtime (vLLM, llama.cpp, Ollama) sous ces interfaces.

Comment Exposer Open WebUI de Façon Sécurisée via HTTPS ?

Deux chemins propres : un Caddyfile de 5 lignes devant Open WebUI pour un vrai certificat Let's Encrypt (quasi-production), ou un Cloudflare Tunnel pour le partage en équipe sans ports ouverts. Les deux maintiennent Open WebUI sur localhost:3000 tout en exposant une URL publique propre avec HTTPS. Choisissez selon que vous contrôlez le DNS d'un domaine ou non.

Le chemin Caddy — pointez votre domaine sur la machine, puis :

ai.example.com {
    reverse_proxy localhost:3000
}

C'est toute la configuration. Caddy récupère automatiquement un certificat Let's Encrypt lors de la première requête. Exécutez caddy run --config Caddyfile (ou utilisez l'unité systemd). Référence complète : documentation Caddy.

Le chemin Cloudflare Tunnel — cloudflared tunnel create open-webui, routez un nom d'hôte dans votre zone Cloudflare, puis cloudflared tunnel run. Aucun port ouvert, Cloudflare gère TLS. Idéal pour "je veux que mon équipe ait accès à ça sans faire de trous dans mon pare-feu."

Une règle stricte : n'exposez jamais le port 3000 brut sur l'internet public. L'inscription dans Open WebUI est ouverte par défaut — n'importe qui atteignant votre URL peut créer un compte. WEBUI_AUTH=False convient au LAN, jamais au public. Toujours mettre un reverse proxy devant plus une liste blanche d'inscription authentifiée (Admin → Paramètres → Général → désactiver "Activer l'inscription" après avoir créé vos comptes).

Comment Techsy Aborde les Déploiements LLM Locaux

Nous avons livré des configurations Open WebUI + Ollama pour des clients dans le droit, la santé et les équipes d'outillage interne qui ne peuvent pas (ou ne veulent pas) envoyer des données à OpenAI. Les patterns se répètent assez pour qu'on ait arrêté de les écrire depuis zéro — mais chaque déploiement a les mêmes trois priorités.

Ce que nous faisons réellement :

• Dimensionner le modèle au matériel et au budget. La plage 3B–8B atteint le meilleur compromis plus souvent qu'autrement. Plus grand n'est pas toujours mieux quand la latence et le coût mensuel comptent.
• Durcir le déploiement. Caddy devant, inscription désactivée, /app/backend/data sur un volume nommé sauvegardé, snapshots hebdomadaires et un vrai plan de reprise après sinistre.
• Câbler des Pipelines pour les besoins spécifiques à l'organisation. Filtres de suppression des PII, pipelines RAG personnalisés pointant vers SharePoint ou Confluence internes, outils d'appel de fonctions pour un accès shell sécurisé — les choses qui rendent une interface de chat réellement utile dans une entreprise.

Si vous préférez sauter la configuration et recevoir une pile IA privée toute prête, réservez une consultation gratuite. Nous serons ravis d'en définir le périmètre.

Récapitulatif

Trois récapitulatifs rapides :

• Chemin conteneur unique — façon la plus rapide d'arriver au premier chat, dix honnêtes minutes sur une machine déjà configurée.
• Docker Compose — ce que vous voulez vraiment pour tout ce qui doit survivre à un redémarrage.
• Pipelines + RAG + MCP — le fossé qui fait qu'Open WebUI vaut le choix par rapport à LM Studio ou Jan.

Vous chattez avec votre propre IA en dix minutes. À partir de là, c'est tout incrémental — ajoutez RAG quand vous avez des documents, ajoutez Caddy quand vous voulez l'utiliser sur votre téléphone, ajoutez Pipelines quand vous voulez qu'il fasse du vrai travail. Si vous voulez aller plus loin dans la sélection de modèles locaux, notre guide sur l'exécution locale des LLMs couvre l'aspect matériel en profondeur.

FAQ

Comment installer Open WebUI avec Ollama ?

Trois étapes : installez Docker Desktop, installez Ollama (curl -fsSL https://ollama.com/install.sh | sh sur macOS/Linux), puis exécutez le conteneur Open WebUI canonique avec docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main. Ouvrez http://localhost:3000 et créez votre compte administrateur.

Open WebUI est-il gratuit ?

Oui — Open WebUI est sous licence MIT et entièrement open-source. L'auto-hébergement est gratuit ; vous payez uniquement pour le matériel qui le fait tourner (votre laptop, un serveur homelab ou une VM cloud). Les pièces payantes optionnelles incluent l'API TTS d'OpenAI pour la voix ou les modèles commerciaux accessibles via le connecteur compatible OpenAI d'Open WebUI. Tout ce qui est essentiel est gratuit.

Open WebUI peut-il fonctionner sans Ollama ?

Oui — Open WebUI parle à n'importe quelle API compatible OpenAI. Vous pouvez le pointer directement vers OpenAI, Anthropic via un proxy LiteLLM, des serveurs vLLM, le serveur HTTP de llama.cpp ou des fournisseurs hébergés comme Groq et Together. Mais "Open WebUI + Ollama" est la combinaison IA locale canonique parce qu'Ollama rend la gestion des modèles extrêmement simple.

Pourquoi Open WebUI ne peut pas se connecter à Ollama ?

Cause la plus courante : flag --add-host=host.docker.internal:host-gateway manquant et OLLAMA_BASE_URL non défini dans les paramètres d'Open WebUI. Deuxième cause la plus courante : Ollama lié uniquement à 127.0.0.1, inaccessible depuis l'intérieur du conteneur — corrigez avec OLLAMA_HOST=0.0.0.0:11434 ollama serve. Exécutez docker exec open-webui curl http://host.docker.internal:11434/api/tags pour diagnostiquer rapidement.

Comment ajouter des modèles à Open WebUI ?

Chemin le plus simple : depuis l'hôte, exécutez ollama pull llama3.2:3b (ou n'importe quel modèle depuis ollama.com/library). Le modèle apparaît automatiquement dans le menu déroulant d'Open WebUI — pas besoin de redémarrage. Alternativement, dans Open WebUI allez dans Admin → Paramètres → Connexions → Ollama et utilisez le bouton pull dans l'interface. Dans tous les cas, les modèles vivent côté Ollama.

Quelle est la différence entre Open WebUI et LM Studio ?

LM Studio est une application desktop mono-utilisateur axée sur la gestion des modèles plus le chat — bons paramètres GPU par défaut, interface soignée, pas de multi-utilisateur. Open WebUI est un serveur auto-hébergé supportant plusieurs utilisateurs, RAG natif, entrée/sortie vocale, Pipelines/Functions et MCP. Audiences différentes : LM Studio pour les utilisateurs desktop solo, Open WebUI pour les équipes ou quiconque veut un ChatGPT privé extensible.

Puis-je utiliser Open WebUI sur un téléphone ?

Oui — Open WebUI est entièrement responsive, donc n'importe quel navigateur mobile fonctionne. Associez-le à HTTPS (Caddy avec un certificat Let's Encrypt ou un Cloudflare Tunnel) et ça devient une application de chat mobile entièrement fonctionnelle. Ajoutez-le à votre écran d'accueil sur iOS ou Android pour une expérience PWA quasi-native. N'exposez pas publiquement sans authentification.

Comment mettre à jour Open WebUI ?

Récupérez la dernière image et redémarrez : docker pull ghcr.io/open-webui/open-webui:main && docker stop open-webui && docker rm open-webui puis relancez votre commande docker run originale. Les volumes nommés préservent toutes les données — historique de chat, utilisateurs, collections RAG et paramètres. Avec Docker Compose : docker compose pull && docker compose up -d. Les mises à jour sont publiées environ toutes les semaines.

Open WebUI supporte-t-il le chat vocal ?

Oui — à la fois la reconnaissance vocale (via faster-whisper local) et la synthèse vocale (via l'API TTS d'OpenAI ou coqui-tts local). Configurez les deux dans Admin → Paramètres → Audio. Une fois activé, une icône microphone apparaît dans la boîte de chat. La configuration pragmatique est Whisper local plus OpenAI TTS — entrée entièrement hors ligne, sortie rapide et propre. Voir la section Entrée/Sortie Vocale ci-dessus pour la configuration des variables d'environnement.

Comment ajouter mes PDFs à Open WebUI ?

Cliquez sur votre profil → Workspace → Connaissances → Nouvelle collection, puis téléchargez des PDFs, des documents Word, du Markdown ou des fichiers texte. Open WebUI découpe les documents, les intègre avec nomic-embed-text (téléchargez-le d'abord via ollama pull nomic-embed-text) et les stocke dans ChromaDB. Référencez n'importe quelle collection dans le chat avec #nom-collection ou attachez-la de façon permanente à un Modèle Personnalisé.