Créer un chatbot IA local avec Ollama et Open WebUI : Partie 2
Intégrer ses propres données à son chatbot (RAG et personnalisation)

Dans la première partie, nous avons vu que le modèle représente la "personnalité" de notre chatbot et qu’il possède des "connaissances" générales issues de son entraînement. Nous pourrions être tentés de créer notre propre modèle afin de l’entraîner sur nos jeux de données et l’adapter à nos besoins spécifiques. Malheureusement, cela impliquerait des compétences avancées en machine learning ainsi que des ressources matérielles largement inaccessibles au commun des mortels. Il faudrait également renouveler l'opération à chaque modification de notre documentation.

Heureusement, une autre approche existe.

Principes du RAG

Prenons le fait d’actualité fictif suivant :

(md)
📋 Copier
1Le 12 février 2036, la ville de Montlortet-sur-Lac a inauguré un nouveau centre de recherche en énergie renouvelable appelé Helios Lab.  
2Ce centre est spécialisé dans le stockage d’énergie solaire par batteries sodium-air, une technologie encore peu répandue en Europe.  
3Le projet a coûté 48 millions d’euros et a été financé à 60 % par la région, 30 % par un consortium privé, et 10 % par des fonds européens.  
4Helios Lab prévoit la création de 120 emplois d’ici 2028, dont 45 postes dédiés à la recherche fondamentale.  
5La directrice du centre est également spécialiste des matériaux à haute densité énergétique.

Si nous donnons ce texte au modèle, puis que nous lui posons la question suivante :
Qui finance majoritairement le projet Helios Lab et combien d’emplois seront créés d’ici 2028 ?
sera-t-il capable de répondre ? Oui, et c’est précisément ce qui nous intéresse ici.

RAG signifie Retrieval Augmented Generation ou génération à enrichissement contextuel en français. Plutôt que d’entraîner le modèle avec nos données, nous allons créer une base de connaissances indépendante et injecter les éléments pertinents au moment de la question.

Le modèle se comporte alors comme un étudiant effectuant un travail de recherche. Le RAG lui permet de consulter des documents avant de formuler sa réponse.

L’avantage majeur de cette approche est qu’elle permet des mises à jour fréquentes de la base documentaire sans avoir à modifier le modèle lui-même.

Mise en œuvre d’un RAG

Nous venons de voir le principe du RAG. Voyons maintenant comment le mettre en œuvre.

En théorie, nous pourrions simplement injecter l’ensemble de notre documentation dans le prompt à chaque question. En pratique, cette approche ne fonctionne pas à grande échelle :

• Les modèles ont une limite de tokens (taille maximale du contexte) ;
• Injecter trop de texte augmente le temps de réponse ;
• Plus le contexte est volumineux, plus le risque de confusion augmente.

Un RAG performant repose donc sur un mécanisme capable de sélectionner uniquement les passages les plus pertinents avant de les transmettre au modèle.

Pour cela, on utilise généralement un système d’embeddings et une base vectorielle.

Les embeddings

Un moteur de recherche classique fonctionne souvent par mots-clés : il découpe la requête en mots individuels, puis cherche leur présence dans les documents. Cette méthode peut fonctionner, mais elle montre rapidement ses limites dès que la formulation varie (déprimé ≠ tristesse).

Les embeddings reposent sur une approche différente. Un modèle d’embeddings transforme un texte en vecteur numérique (une série de nombres). Deux textes ayant un sens proche auront des vecteurs proches dans l’espace vectoriel, même s’ils n’utilisent pas exactement les mêmes mots (Connaissez-vous Cémantix ?).

Concrètement :

1. Les documents sont découpés en morceaux (chunks) ;
2. Chaque morceau est transformé en vecteur ;
3. Ces vecteurs sont stockés dans une base vectorielle ;
4. Lorsqu’un utilisateur pose une question, celle-ci est également transformée en vecteur ;
5. Le système recherche les vecteurs les plus proches ;
6. Les passages correspondants sont injectés dans le prompt du modèle.

Le modèle de langage ne “connaît” donc pas la base documentaire en permanence. Il reçoit uniquement les éléments pertinents au moment de la question.

Pour simplifier ce processus, j’ai décidé d’utiliser Open WebUI.

Présentation d'Open WebUI

Open WebUI fournit une surcouche à Ollama et intègre nativement :

• Un système d’indexation documentaire dans une base vectorielle ;
• La prise en charge de différents formats (texte, PDF, images, etc.) ;
• Une interface graphique ;
• Une gestion simplifiée du RAG.

Cela permet de mettre en place une architecture RAG sans développer l’ensemble soi-même.

Installation d'Open WebUI

Prérequis

Il existe plusieurs méthodes d’installation. Pour un POC local, je propose d'utiliser Docker. Vous trouverez sur la page GitHub d'autres méthodes d'installation.

Ainsi, les prérequis sont :

• Avoir Ollama installé et fonctionnel ;
• Avoir Docker installé sur votre machine.

Pour vérifier qu’Ollama est accessible en ligne de commande, vous pouvez saisir la commande suivante :

(bash)
📋 Copier
1ollama list

Si la commande retourne vos modèles installés, tout est prêt. Sinon, retournez lire la partie précédente.

Installation via Docker

Lancez la commande suivante :

(bash)
📋 Copier
1docker run -d \
2  -p 3000:8080 \
3  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
4  -v open-webui:/app/backend/data \
5  --name open-webui \
6  ghcr.io/open-webui/open-webui:main

Explications :

• -p 3000:8080 : expose l’interface sur http://localhost:3000 ;
• OLLAMA_BASE_URL : indique à Open WebUI comment joindre Ollama ;
• -v open-webui:/app/backend/data : monte un volume Docker persistant.

Une fois lancé, ouvrez votre navigateur à l’adresse : http://localhost:3000.

Lors du premier démarrage, la création d'un compte administrateur vous sera demandée.

Vérification du lien entre Open WebUI et Ollama

Si la variable OLLAMA_BASE_URL a été correctement définie, Open WebUI détectera automatiquement Ollama.

Pour vérifier :

1. Aller dans les paramètres (Settings) ;
2. Ouvrir la section Models ;
3. Vérifier que vos modèles Ollama apparaissent (ex : mistral-nemo).

Importer des connaissances (Knowledge)

Une fois la connexion établie, avec le compte administrateur :

1. Rendez-vous dans la section "Knowledge/connaissances" du "Workspace/Espace de travail" ;
2. Créer une nouvelle base de connaissances ;
3. Importer vos fichiers (par exemple des fichiers en Markdown .md) ;
4. Vérifiez le contenu des fichiers en cliquant dessus.

Open WebUI va :

• Découper les documents en morceaux plus petits nommés chunks ;
• Générer des embeddings pour chaque chunk ;
• Les stocker dans une base vectorielle.

Vous pouvez dès à présent créer une nouvelle conversation et ajouter votre base de connaissances en cliquant sur le +, puis joindre une connaissance.

Associer la base documentaire à un modèle

Pour que votre connaissance soit lié de manière plus durable à votre modèle, je vous propose de créer votre propre "modèle OpenWebUI".

Pour cela, avec le compte administrateur :

1. rendez-vous dans "Espace de travail/Workspace" ;
2. cliquez sur "New model" ;
3. renseignez un nom de modèle (ex : "Mon assistant personnalisé") ;
4. sélectionnez le modèle Ollama de base ;
5. dans la partie connaissance, sélectionnez votre (ou vos) base de connaissances ;
6. enregistrez.

Désormais, à chaque question :

• La requête est transformée en embeddings ;
• Les passages les plus pertinents sont récupérés ;
• Ils sont injectés dans le prompt ;
• Le modèle génère la réponse à partir de ces éléments.

Personnaliser le comportement

Une fois le RAG en place, vous pouvez affiner le comportement du modèle "Open WebUI" en lui définissant un prompt système pour :

• Lui demander de répondre uniquement à partir des documents ;
• Indiquer qu’il doit signaler l’absence d’information ;
• Ajuster la température pour réduire la créativité.

Exemple de consigne système :
Réponds uniquement à partir des documents fournis dans le contexte. Si l’information n’est pas présente, indique clairement que tu ne sais pas. Termine toujours ton message par une formule de politesse différente. Si l'utilisateur évoque des pensées très tristes, oriente le vers la médecine du travail.

Récapitulatif de l’architecture

À ce stade, l’architecture est la suivante :

• Ollama exécute le modèle de langage ;
• Le modèle génère les réponses ;
• Open WebUI fournit l’interface ;
• Open WebUI gère l’indexation documentaire ;
• Le RAG sélectionne et injecte les documents pertinents au moment de la question.

On obtient ainsi :

• Un chatbot local ;
• Un système entièrement hors ligne ;
• Une base documentaire intégrée ;
• Une architecture simple et compréhensible.

Conclusion

Déployer un chatbot IA local avec intégration documentaire est tout à fait réalisable sur une machine personnelle.

Les performances ne rivalisent pas avec une infrastructure cloud, mais elles sont suffisantes pour :

• Créer un POC ;
• Tester l’intégration de données internes ;
• Comprendre le fonctionnement d’un assistant local ;
• Préparer une montée en charge future.

Cette approche permet de construire un assistant maîtrisé, évolutif et entièrement hors ligne, sans complexité excessive.